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);
}
/// <summary>Execute the given command message.
/// </summary>
/// <param name="message">The command message.</param>
/// <param name="queue">The queue which the command message belongs to.</param>
public override void Execute(ICommand message, IMessageQueue<ICommand> queue)
{
var command = message;
var commandHandler = _commandHandlerProvider.GetCommandHandler(command);
if (commandHandler == null)
{
var errorMessage = string.Format("Command handler not found for {0}", command.GetType().FullName);
_logger.Fatal(errorMessage);
_commandAsyncResultManager.TryComplete(command.Id, null, new ErrorInfo(errorMessage));
FinishExecution(command, queue);
return;
}
try
{
_trackingContext.Clear();
_processingCommandCache.Add(command);
commandHandler.Handle(_commandContext, command);
var dirtyAggregate = GetDirtyAggregate(_trackingContext);
if (dirtyAggregate != null)
{
CommitAggregate(dirtyAggregate, command, queue);
}
else
{
_logger.Info("No dirty aggregate found, finish the command execution directly.");
_commandAsyncResultManager.TryComplete(command.Id, null);
FinishExecution(command, queue);
}
}
catch (Exception ex)
{
var commandHandlerType = commandHandler.GetInnerCommandHandler().GetType();
var errorMessage = string.Format("Exception raised when {0} handling {1}, command id:{2}.", commandHandlerType.Name, command.GetType().Name, command.Id);
_logger.Error(errorMessage, ex);
_commandAsyncResultManager.TryComplete(command.Id, null, new ErrorInfo(errorMessage, ex));
FinishExecution(command, queue);
}
finally
{
_trackingContext.Clear();
}
}
/// <summary>Retry the given command.
/// </summary>
/// <param name="commandInfo"></param>
/// <param name="eventStream"></param>
/// <param name="errorInfo"></param>
/// <param name="retrySuccessCallbackAction"></param>
public void RetryCommand(CommandInfo commandInfo, EventStream eventStream, ErrorInfo errorInfo, ActionInfo retrySuccessCallbackAction)
{
if (_retryCommandQueue == null)
{
_retryCommandQueue = Configuration.Instance.GetRetryCommandQueue();
}
var command = commandInfo.Command;
Action <CommandInfo, ActionInfo> actionAfterCommandRetried = (currentCommandInfo, callbackActionInfo) =>
{
currentCommandInfo.IncreaseRetriedCount();
_logger.InfoFormat("Sent {0} to command retry queue for {1} time.", currentCommandInfo.Command.GetType().Name, currentCommandInfo.RetriedCount);
callbackActionInfo.Action(callbackActionInfo.Data);
};
if (commandInfo.RetriedCount < command.RetryCount)
{
if (_retryService.TryAction("TryEnqueueCommand", () => TryEnqueueCommand(command), 2))
{
actionAfterCommandRetried(commandInfo, retrySuccessCallbackAction);
}
else
{
_retryService.RetryInQueue(
new ActionInfo(
"TryEnqueueCommand",
(obj) => TryEnqueueCommand(obj as ICommand),
command,
new ActionInfo(
"TryEnqueueCommandFinishedAction",
(obj) =>
{
var data = obj as dynamic;
var currentCommandInfo = data.CommandInfo as CommandInfo;
var callbackActionInfo = data.Callback as ActionInfo;
actionAfterCommandRetried(currentCommandInfo, callbackActionInfo);
return(true);
},
new { CommandInfo = commandInfo, Callback = retrySuccessCallbackAction },
null)));
}
}
else
{
_commandAsyncResultManager.TryComplete(commandInfo.Command.Id, eventStream.AggregateRootId, errorInfo.ErrorMessage, errorInfo.Exception);
}
}
/// <summary>Retry the given command.
/// </summary>
/// <param name="commandInfo"></param>
/// <param name="eventStream"></param>
/// <param name="errorInfo"></param>
/// <param name="retrySuccessCallbackAction"></param>
public void RetryCommand(CommandInfo commandInfo, EventStream eventStream, ErrorInfo errorInfo, Action retrySuccessCallbackAction)
{
if (_retryCommandQueue == null)
{
_retryCommandQueue = Configuration.Instance.GetRetryCommandQueue();
}
var command = commandInfo.Command;
if (commandInfo.RetriedCount < command.RetryCount)
{
_retryService.TryAction("TryEnqueueCommand", () => TryEnqueueCommand(commandInfo), 3, retrySuccessCallbackAction);
}
else
{
_commandAsyncResultManager.TryComplete(command.Id, eventStream.AggregateRootId, errorInfo);
_logger.InfoFormat("{0} retried count reached to its max retry count {1}.", command.GetType().Name, command.RetryCount);
if (retrySuccessCallbackAction != null)
{
retrySuccessCallbackAction();
}
}
}
