private void Clear(EventStreamContext context, ErrorInfo errorInfo)
{
if (errorInfo != null)
{
_commandAsyncResultManager.TryComplete(context.EventStream.CommandId, context.EventStream.AggregateRootId, errorInfo.ErrorMessage, errorInfo.Exception);
}
else
{
_commandAsyncResultManager.TryComplete(context.EventStream.CommandId, context.EventStream.AggregateRootId);
}
_processingCommandCache.TryRemove(context.EventStream.CommandId);
FinishExecution(context.EventStream, context.Queue);
}
private void TryDispatchEventsToEventHandlers(EventStreamContext context)
{
Func <EventStreamContext, bool> tryDispatchEventsAction = (streamContext) => {
if (streamContext.EventStream.Version == 1)
{
return(DispatchEventsToHandlers(streamContext.EventStream));
}
else
{
var lastPublishedVersion = _eventPublishInfoStore.GetEventPublishedVersion(streamContext.EventStream.AggregateRootId);
if (lastPublishedVersion + 1 == streamContext.EventStream.Version)
{
return(DispatchEventsToHandlers(streamContext.EventStream));
}
else if (lastPublishedVersion + 1 > streamContext.EventStream.Version)
{
return(true);
}
return(false);
}
};
try {
if (_retryService.TryAction("TryDispatchEvents", () => tryDispatchEventsAction(context), 3))
{
Clear(context);
}
else
{
_retryService.RetryInQueue(
new ActionInfo(
"TryDispatchEvents",
(obj) => tryDispatchEventsAction(obj as EventStreamContext),
context,
new ActionInfo(
"DispatchEventsSuccessAction",
(data) => { Clear(data as EventStreamContext); return(true); },
context, null)
)
);
}
}
catch (Exception ex) {
_logger.Error(string.Format("Exception raised when dispatching events:{0}", context.EventStream.GetStreamInformation()), ex);
}
}
private bool CommitEvents(EventStreamContext eventStreamContext)
{
var errorInfo = new ErrorInfo();
var synchronizeResult = TryCallSynchronizersBeforeEventPersisting(eventStreamContext.EventStream, errorInfo);
if (synchronizeResult == SynchronizeResult.SynchronizerConcurrentException)
{
return(false);
}
else if (synchronizeResult == SynchronizeResult.Failed)
{
Clear(eventStreamContext, errorInfo);
return(true);
}
else
{
var persistSuccessActionInfo = new ActionInfo(
"PersistSuccessAction",
(obj) => {
var context = obj as EventStreamContext;
if (context.HasConcurrentException)
{
var retryCommandSuccessAction = new ActionInfo(
"RetryCommandSuccessAction",
(data) => {
var streamContext = data as EventStreamContext;
FinishExecution(streamContext.EventStream, streamContext.Queue);
return(true);
},
context, null);
RetryCommand(context, context.ErrorInfo, retryCommandSuccessAction);
}
else
{
TryRefreshMemoryCache(context.EventStream);
TryCallSynchronizersAfterEventPersisted(context.EventStream);
TryPublishEvents(context.EventStream, new ActionInfo("PublishSuccessAction", (data) => { Clear(data as EventStreamContext); return(true); }, context, null));
}
return(true);
},
eventStreamContext,
null);
TryPersistEvents(eventStreamContext, persistSuccessActionInfo);
return(true);
}
}
private void RetryCommand(EventStreamContext eventStreamContext, ErrorInfo errorInfo, ActionInfo successActionInfo)
{
if (!eventStreamContext.EventStream.IsRestoreFromStorage())
{
var command = _processingCommandCache.Get(eventStreamContext.EventStream.CommandId);
if (command != null)
{
_retryCommandService.RetryCommand(command, eventStreamContext.EventStream, errorInfo, successActionInfo);
}
else
{
_logger.ErrorFormat("The command need to retry cannot be found from command processing cache, commandId:{0}", eventStreamContext.EventStream.CommandId);
}
}
else
{
_logger.InfoFormat("The command with id {0} will not be retry as the current event stream is restored from the message store.", eventStreamContext.EventStream.CommandId);
}
}
public override void Execute(EventStream message, IMessageQueue <EventStream> queue)
{
var eventStreamContext = new EventStreamContext {
EventStream = message, Queue = queue
};
Func <EventStreamContext, bool> tryCommitEventsAction = (context) => {
try {
return(CommitEvents(context));
}
catch (Exception ex) {
_logger.Error(string.Format("Exception raised when committing events:{0}.", context.EventStream.GetStreamInformation()), ex);
return(false);
}
};
if (!_retryService.TryAction("TryCommitEvents", () => tryCommitEventsAction(eventStreamContext), 3))
{
_retryService.RetryInQueue(new ActionInfo("TryCommitEvents", (obj) => tryCommitEventsAction(obj as EventStreamContext), eventStreamContext, null));
}
}
private void TryPersistEvents(EventStreamContext eventStreamContext, ActionInfo successActionInfo)
{
Func <EventStreamContext, bool> tryPersistEventsAction = (context) => {
try {
_eventStore.Append(context.EventStream);
return(true);
}
catch (Exception ex) {
if (ex is ConcurrentException && IsEventStreamCommitted(context.EventStream))
{
return(true);
}
var errorMessage = string.Format("{0} raised when persisting events:{1}", ex.GetType().Name, context.EventStream.GetStreamInformation());
_logger.Error(errorMessage, ex);
if (ex is ConcurrentException)
{
context.SetConcurrentException(new ErrorInfo {
ErrorMessage = errorMessage, Exception = ex
});
return(true);
}
return(false);
}
};
if (_retryService.TryAction("TryPersistEvents", () => tryPersistEventsAction(eventStreamContext), 3))
{
successActionInfo.Action(successActionInfo.Data);
}
else
{
_retryService.RetryInQueue(new ActionInfo("TryPersistEvents", (obj) => tryPersistEventsAction(obj as EventStreamContext), eventStreamContext, successActionInfo));
}
}
private void Clear(EventStreamContext context)
{
UpdatePublishedEventStreamVersion(context.EventStream);
FinishExecution(context.EventStream, context.Queue);
}
private void Clear(EventStreamContext context)
{
Clear(context, null);
}
