public IAggregate CreateFrom(DomainEvent @event)
{
IAggregate aggregate = null;
Func<IAggregate> factory;
var isCreationEvent = factoryMethods.TryGetValue(@event.GetType(), out factory);
if (isCreationEvent)
{
aggregate = factory();
aggregate.ApplyEvent(@event);
}
return aggregate;
}
public void Send(DomainEvent @event)
{
foreach (var registration in componentContext.ComponentRegistry.Registrations) {
foreach (var service in registration.Services.OfType<TypedService>()) {
var type = service.ServiceType;
if (!type.IsInterface || !type.IsGenericType || !type.IsConstructedGenericType ||
type.GetGenericTypeDefinition() != typeof (IHandleDomainEvents<>)) {
continue;
}
var method = type.GetMethod("Handle");
if (Enumerable.Any<ParameterInfo>(method.GetParameters(), x => x.ParameterType == @event.GetType())) {
var handler = componentContext.ResolveComponent(registration, new List<Parameter>());
method.Invoke(handler, new[] {@event});
}
}
}
}
private void InnerDispatch(DomainEvent @event)
{
var executors = _catalog.GetAllHandlerFor(@event.GetType());
foreach (var executor in executors)
{
try
{
if (_logger.IsDebugEnabled) _logger.Debug("Dispatching event " + @event.GetType() + " to the handler " + executor.DefiningType + "." + executor.Invoker.Method.Name);
executor.Invoke(@event);
if (_logger.IsDebugEnabled) _logger.Debug("Dispatched event " + @event.GetType() + " to the handler " + executor.DefiningType + "." + executor.Invoker.Method.Name);
}
catch (OutOfMemoryException)
{
throw;
}
catch (Exception ex)
{
_logger.Error("Error during dispatching event " + @event.GetType() + " to the handler " + executor.DefiningType + "." + executor.Invoker.Method.Name, ex);
}
}
}
/// <summary>
/// Dispatches the given domain event to the view instance. The view instance's <see cref="IViewInstance.LastGlobalSequenceNumber"/>
/// will automatically be updated after successful dispatch. If the global sequence number of the event is lower or equal to the
/// view instance's <see cref="IViewInstance.LastGlobalSequenceNumber"/>, the event is ignored.
/// </summary>
public void DispatchToView(IViewContext context, DomainEvent domainEvent, TViewInstance view)
{
var lastGlobalSequenceNumber = domainEvent.GetGlobalSequenceNumber();
if (lastGlobalSequenceNumber <= view.LastGlobalSequenceNumber)
{
return;
}
var domainEventType = domainEvent.GetType();
var dispatcherMethod = _dispatcherMethods
.GetOrAdd(domainEventType, type => _dispatchToViewGenericMethod.MakeGenericMethod(domainEventType));
try
{
var viewId = view.Id;
_logger.Debug("Dispatching event {0} to {1} with ID {2}", lastGlobalSequenceNumber, view, viewId);
context.CurrentEvent = domainEvent;
dispatcherMethod.Invoke(this, new object[] { context, domainEvent, view });
view.Id = viewId;
view.LastGlobalSequenceNumber = lastGlobalSequenceNumber;
}
catch (TargetInvocationException exception)
{
throw new ApplicationException(string.Format("Could not dispatch {0} to {1}", domainEvent, view), exception.InnerException);
}
catch (Exception exception)
{
throw new ApplicationException(string.Format("Could not dispatch {0} to {1}", domainEvent, view), exception);
}
}
public async Task Publish(DomainEvent domainEvent)
{
_logger.LogInformation("Publishing domain event. Event - {event}", domainEvent.GetType().Name);
await _mediator.Publish(GetNotificationCorrespondingToDomainEvent(domainEvent));
}
public bool CanMap(DomainEvent @event)
{
return(@event.GetType() == typeof(AccommodationLeadCreated));
}
private static IDomainEventMessage CreateDomainEventMessage(DomainEvent domainEvent)
{
var domainEventMessageType = typeof(DomainEventMessage <>).MakeGenericType(domainEvent.GetType());
var message = (IDomainEventMessage)Activator.CreateInstance(domainEventMessageType);
message.DomainEvent = domainEvent;
return(message);
}
public void RegisterTimeSpent(IViewManager viewManager, DomainEvent domainEvent, TimeSpan duration)
{
TimeSpent.GetOrAdd(viewManager, vm => new ConcurrentDictionary <Type, TimeSpan>())
.AddOrUpdate(domainEvent.GetType(), type => duration, (type, existing) => existing + duration);
}
private static dynamic CreateDynamicEvent(DomainEvent domainEvent)
{
var type = typeof(AfterCommittedEvent <>).MakeGenericType(domainEvent.GetType());
return(Activator.CreateInstance(type, domainEvent));
}
private string FormatCollectionWrapperExceptionMessage(string message, DomainEvent evt)
{
if (evt == null)
{
return($"CollectionWrapper [{typeof(TModel).Name}] - {message}");
}
else
{
return($"CollectionWrapper [{typeof(TModel).Name}] Event Position [{evt.CheckpointToken}] Event Type [{evt.GetType().Name}]- {message}");
}
}
public bool IsCreationEvent(DomainEvent @event)
{
return factoryMethods.ContainsKey(@event.GetType());
}
public void Add(DomainEvent @event)
{
var eventToAdd = new Event(Guid.NewGuid(), @event.GetType().Name, Newtonsoft.Json.JsonConvert.SerializeObject(@event));
_events.Add(eventToAdd);
}
public bool CanMap(DomainEvent @event)
{
return(@event.GetType() == typeof(AuthenticationCreated));
}
private static Type CreateEventHandlerTypeFor(DomainEvent domainEvent) => typeof(DomainEventHandler <>).MakeGenericType(domainEvent.GetType());
public void Publish(DomainEvent domainEvent)
{
var exceptionList = new List <Exception>();
var handleMethod = typeof(IHandleDomainEvents <>).MakeGenericType(domainEventType).GetMethod("Handle");
foreach (var eventHandlerType in eventHandlerTypes)
{
try
{
var eventHandler = eventHandlerFactory.Create(eventHandlerType);
handleMethod.Invoke(eventHandler, new object[] { domainEvent });
}
catch (Exception exception)
{
logger.Error(string.Format("An exception occured while handling event of type '{0}'\nMessage: {1}", domainEvent.GetType(), exception.Message), exception);
exceptionList.Add(exception);
}
}
if (exceptionList.Count > 0)
{
throw new AggregateException(exceptionList);
}
}
private void ApplyChange(DomainEvent domainEvent, bool isNew)
{
var method = GetType().GetMethod("Apply", BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { domainEvent.GetType() }, null);
if (method == null)
{
throw new InvalidOperationException("Apply method not found");
}
method.Invoke(this, new[] { domainEvent });
if (isNew)
{
_changes.Add(domainEvent);
}
}
internal void DispatchEvent(DomainEvent evt)
{
var chkpoint = evt.CheckpointToken;
if (chkpoint > LastCheckpointDispatched)
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Discharded event {0} commit {1} because last checkpoint dispatched for slot {2} is {3}.", evt.CommitId, evt.CheckpointToken, SlotName, _maxCheckpointDispatched);
}
return;
}
Interlocked.Increment(ref RebuildProjectionMetrics.CountOfConcurrentDispatchingCommit);
//Console.WriteLine("[{0:00}] - Slot {1}", Thread.CurrentThread.ManagedThreadId, slotName);
if (_logger.IsDebugEnabled)
{
_logger.ThreadProperties["commit"] = evt.CommitId;
_logger.DebugFormat("Dispatching checkpoit {0} on tenant {1}", evt.CheckpointToken, _config.TenantId);
}
TenantContext.Enter(_config.TenantId);
try
{
if (_logger.IsDebugEnabled)
{
_logger.ThreadProperties["evType"] = evt.GetType().Name;
_logger.ThreadProperties["evMsId"] = evt.MessageId;
_logger.ThreadProperties["evCheckpointToken"] = evt.CheckpointToken;
}
string eventName = evt.GetType().Name;
foreach (var projection in _projections)
{
var cname = projection.GetCommonName();
if (_logger.IsDebugEnabled)
{
_logger.ThreadProperties["prj"] = cname;
}
bool handled;
long ticks = 0;
try
{
//pay attention, stopwatch consumes time.
var sw = new Stopwatch();
sw.Start();
handled = projection.Handle(evt, true);
sw.Stop();
ticks = sw.ElapsedTicks;
MetricsHelper.IncrementProjectionCounterRebuild(cname, SlotName, eventName, ticks);
}
catch (Exception ex)
{
_logger.FatalFormat(ex, "[Slot: {3} Projection: {4}] Failed checkpoint: {0} StreamId: {1} Event Name: {2}",
evt.CheckpointToken,
evt.AggregateId,
eventName,
SlotName,
cname
);
throw;
}
_metrics.Inc(cname, eventName, ticks);
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("[{3}] [{4}] Handled checkpoint {0}: {1} > {2}",
evt.CheckpointToken,
evt.AggregateId,
eventName,
SlotName,
cname
);
}
if (_logger.IsDebugEnabled)
{
_logger.ThreadProperties["prj"] = null;
}
}
ClearLoggerThreadPropertiesForEventDispatchLoop();
}
catch (Exception ex)
{
_logger.ErrorFormat(ex, "Error dispathing commit id: {0}\nMessage: {1}\nError: {2}",
evt.CheckpointToken, evt, ex.Message);
ClearLoggerThreadPropertiesForEventDispatchLoop();
throw;
}
_lastCheckpointRebuilded = chkpoint;
if (_logger.IsDebugEnabled)
{
_logger.ThreadProperties["commit"] = null;
}
Interlocked.Decrement(ref RebuildProjectionMetrics.CountOfConcurrentDispatchingCommit);
}
private PollingClient2.HandlingResult ErrorHandler(DomainEvent evt, Exception ex)
{
var builder = _serviceProvider.GetRequiredService <IHandlerResolver>();
if (builder.TryGetErrorHandler(out var handler) && (bool)handler.DynamicInvoke(evt, ex))
{
_logger.LogError(ex, "Error during handling {EventType}. Will retry.", evt.GetType());
return(PollingClient2.HandlingResult.Retry);
}
_logger.LogCritical(ex, "Error during handling {EventType}. Exit polling.", evt.GetType());
_checkpointLoader.SaveAsync(_currentCheckpoint).GetAwaiter().GetResult();
return(PollingClient2.HandlingResult.Stop);
}
public IEventPublisher CreatePublisher(DomainEvent @event)
{
return(_publishers[@event.GetType()]);
}
/// <summary>
/// Emits the given domain event, adding the aggregate root's <see cref="Id"/> and a sequence number to its metadata, along with some type information
/// </summary>
protected void Emit <TAggregateRoot>(DomainEvent <TAggregateRoot> e) where TAggregateRoot : AggregateRoot
{
if (e == null)
{
throw new ArgumentNullException("e", "Can't emit null!");
}
if (string.IsNullOrWhiteSpace(Id))
{
throw new InvalidOperationException(
string.Format(
"Attempted to emit event {0} from aggregate root {1}, but it has not yet been assigned an ID!",
e, GetType()));
}
var eventType = e.GetType();
var emitterInterface = typeof(IEmit <>).MakeGenericType(eventType);
if (!emitterInterface.IsAssignableFrom(GetType()))
{
throw new InvalidOperationException(
string.Format(
"Attempted to emit event {0} but the aggregate root {1} does not implement IEmit<{2}>",
e, GetType().Name, e.GetType().Name));
}
if (UnitOfWork == null)
{
throw new InvalidOperationException(string.Format("Attempted to emit event {0}, but the aggreate root does not have a unit of work!", e));
}
if (ReplayState != ReplayState.None)
{
throw new InvalidOperationException(string.Format("Attempted to emit event {0}, but the aggreate root's replay state is {1}! - events can only be emitted when the root is not applying events", e, ReplayState));
}
if (!typeof(TAggregateRoot).IsAssignableFrom(GetType()))
{
throw new InvalidOperationException(
string.Format("Attempted to emit event {0} which is owned by {1} from aggregate root of type {2}",
e, typeof(TAggregateRoot), GetType()));
}
var now = Time.UtcNow();
var sequenceNumber = CurrentSequenceNumber + 1;
e.Meta.Merge(CurrentCommandMetadata ?? new Metadata());
e.Meta[DomainEvent.MetadataKeys.AggregateRootId] = Id;
e.Meta[DomainEvent.MetadataKeys.TimeUtc] = now.ToString("u");
e.Meta[DomainEvent.MetadataKeys.SequenceNumber] = sequenceNumber.ToString(Metadata.NumberCulture);
e.Meta.TakeFromAttributes(eventType);
e.Meta.TakeFromAttributes(GetType());
try
{
ApplyEvent(e, ReplayState.EmitApply);
}
catch (Exception exception)
{
throw new ApplicationException(string.Format(@"Could not apply event {0} to {1} - please check the inner exception, and/or make sure that the aggregate root type is PUBLIC", e, this), exception);
}
UnitOfWork.AddEmittedEvent(this, e);
EventEmitted(e);
}
public void RegisterTimeSpent(IViewManager viewManager, DomainEvent domainEvent, TimeSpan duration)
{
_timeSpent.GetOrAdd(viewManager, vm => new ConcurrentDictionary <Type, Tracking>())
.AddOrUpdate(domainEvent.GetType(), type => new Tracking(duration), (type, tracking) => tracking.Update(duration));
}
private IEnumerable GetEventHandlers(DomainEvent @event)
{
var domainEventHandlerType = typeof(IDomainEventHandler <>).MakeGenericType(@event.GetType());
var allEventHandlers = typeof(IEnumerable <>).MakeGenericType(domainEventHandlerType);
return((IEnumerable)_serviceProvider.GetService(allEventHandlers));
}
public string Serialize(DomainEvent domainEvent)
{
return(JsonSerializer.SerializeToString(domainEvent, domainEvent.GetType()));
}
public string ForClass(DomainEvent domainEvent)
{
return(IndexedDomainEvents.FirstOrDefault(x => x.Value.Equals(domainEvent.GetType())).Key);
}
public bool CanMap(DomainEvent @event)
{
return(@event.GetType() == typeof(UserCreated));
}
public IEnumerable <SubscriptionInfo> GetHandlersForEvent(DomainEvent domainEvent)
{
var key = GetEventKey(domainEvent.GetType());
return(GetHandlersForEvent(key));
}
static void onLog(DomainEvent avisadoEstas)
{
Console.WriteLine($"LOG => {DateTime.UtcNow} Evento capturado {avisadoEstas.OccuredOn} - Type {avisadoEstas.GetType()}");
}
private INotification GetNotificationCorrespondingToDomainEvent(DomainEvent domainEvent)
{
return((INotification)Activator.CreateInstance(
typeof(DomainEventNotification <>).MakeGenericType(domainEvent.GetType()), domainEvent));
}
public async Task Publish(DomainEvent domainEvent)
{
_logger.LogInformation(PublishInformationMessage, domainEvent.GetType().Name);
await _mediator.Publish(GetNotificationCorrespondingToDomainEvent(domainEvent));
}