/// <summary>Commit the dirty aggregate's domain events to the eventstore and publish the domain events.
/// </summary>
public void CommitEvent(EventProcessingContext context)
{
var commitEvents = new Func<bool>(() =>
{
try
{
return CommitEvents(context);
}
catch (Exception ex)
{
_logger.Error(string.Format("Exception raised when committing events:{0}.", context.EventStream), ex);
return false;
}
});
_actionExecutionService.TryAction("CommitEvents", commitEvents, 3, null);
}
private void RetryCommand(EventProcessingContext context)
{
_retryCommandService.RetryCommand(context.ProcessingCommand);
}
private void PersistEvents(EventProcessingContext context, ActionInfo successCallback)
{
var persistEvents = new Func<bool>(() =>
{
try
{
context.AppendResult = _eventStore.Append(_eventStreamConvertService.ConvertTo(context.EventStream));
return true;
}
catch (Exception ex)
{
if (ex is ConcurrentException || ex is DuplicateAggregateException)
{
context.Exception = ex as ENodeException;
return true;
}
_logger.Error(string.Format("{0} raised when persisting events:{1}", ex.GetType().Name, context.EventStream), ex);
return false;
}
});
_actionExecutionService.TryAction("PersistEvents", persistEvents, 3, successCallback);
}
private void RefreshMemoryCache(EventProcessingContext context)
{
try
{
_eventSourcingService.ReplayEvents(context.AggregateRoot, new EventStream[] { context.EventStream });
_memoryCache.Set(context.AggregateRoot);
}
catch (Exception ex)
{
_logger.Error(string.Format("Exception raised when refreshing memory cache by event stream:{0}", context.EventStream), ex);
}
}
private bool CommitEvents(EventProcessingContext context)
{
var synchronizerResult = SyncBeforeEventPersisting(context.EventStream);
switch (synchronizerResult.Status)
{
case SynchronizeStatus.SynchronizerConcurrentException:
return false;
case SynchronizeStatus.Failed:
context.ProcessingCommand.CommandExecuteContext.OnCommandExecuted(
context.ProcessingCommand.Command,
CommandStatus.Failed,
synchronizerResult.ExceptionCode,
synchronizerResult.ErrorMessage);
return true;
default:
{
var persistEventsCallback = new Func<object, bool>(obj =>
{
var currentContext = obj as EventProcessingContext;
var eventStream = currentContext.EventStream;
if (currentContext.AppendResult == EventAppendResult.Success)
{
RefreshMemoryCache(currentContext);
SendWaitingCommand(eventStream);
SyncAfterEventPersisted(eventStream);
PublishEvents(currentContext.ProcessingCommand.CommandExecuteContext.Items, currentContext.ProcessingCommand, eventStream);
}
else if (currentContext.AppendResult == EventAppendResult.DuplicateCommit)
{
SendWaitingCommand(eventStream);
var existingEventStream = GetEventStream(eventStream.AggregateRootId, eventStream.CommitId);
if (existingEventStream != null)
{
SyncAfterEventPersisted(existingEventStream);
PublishEvents(currentContext.ProcessingCommand.CommandExecuteContext.Items, currentContext.ProcessingCommand, existingEventStream);
}
else
{
_logger.ErrorFormat("Duplicate commit, but can't find the existing eventstream from eventstore. commandId:{0}, aggregateRootId:{1}, aggregateRootTypeCode:{2}",
eventStream.CommitId,
eventStream.AggregateRootId,
eventStream.AggregateRootTypeCode);
}
}
else if (currentContext.Exception != null)
{
if (currentContext.Exception is DuplicateAggregateException)
{
currentContext.ProcessingCommand.CommandExecuteContext.OnCommandExecuted(
currentContext.ProcessingCommand.Command,
CommandStatus.Failed,
0,
currentContext.Exception.Message);
}
else if (currentContext.Exception is ConcurrentException)
{
RefreshMemoryCacheFromEventStore(eventStream);
RetryCommand(currentContext);
}
}
return true;
});
PersistEvents(context, new ActionInfo("PersistEventsCallback", persistEventsCallback, context, null));
return true;
}
}
}
