private void ProcessFault(ICommand cmd, Exception ex, IMessageMetadata messageMetadata)
{
var fault = Fault.NewGeneric(cmd, ex, typeof(TAggregate), cmd.SagaId);
var metadata = messageMetadata.CreateChild(cmd.Id,
new ProcessEntry(Self.Path.Name,
CreatedFault,
CommandRaisedAnError));
Publisher.Publish(fault, metadata);
Log.Error(ex, "{Aggregate} raised an expection {@Exception} while executing {@Command}", State.Id, ex, cmd);
}
private IFault PublishError(Exception exception)
{
var command = ExecutionContext.Command;
Log.Error(exception, "An error occured while command execution. {@context}", ExecutionContext);
var producedFaultMetadata = ExecutionContext.CommandMetadata.CreateChild(command.Id, _domainEventProcessFailEntry);
var fault = Fault.NewGeneric(command, exception, command.ProcessId, typeof(TAggregate));
Project(fault, producedFaultMetadata);
ExecutionContext.CommandSender.Tell(fault);
return(fault);
}
protected virtual void PublishError(TMessage msg, IMessageMetadata metadata, Exception ex)
{
_log.Error(ex,
"Handler actor raised an error on message process: {@msg}. Count: {count}",
msg,
++_publishFaultCount);
var faultMetadata = metadata.CreateChild(msg.Id, FaltProcessEntry);
var fault = Fault.NewGeneric(msg, ex, msg.ProcessId, typeof(THandler));
Publisher.Publish(fault, faultMetadata);
}
private void FinishWithError(IMessageMetadataEnvelop processingMessage, IActorRef messageSender, Exception error)
{
_log.Error(error, "Error during execution of message {@message}", processingMessage);
var processorType = Process?.GetType() ?? typeof(TState);
var fault = (IFault)Fault.NewGeneric(processingMessage.Message, error.UnwrapSingle(), Id, processorType);
var faultMetadata = MessageMetadataExtensions.CreateChild(processingMessage.Metadata, (string)fault.ProcessId, _exceptionOnTransit);
_publisher.Publish(fault, faultMetadata);
messageSender.Tell(new ProcessFault(fault, processingMessage.Metadata));
Behavior.Become(AwaitingMessageBehavior, nameof(AwaitingMessageBehavior));
ExecutionContext.Clear();
}
private void ProcessSaga(object message, IMessageMetadata messageMetadata)
{
try
{
Saga.Transit(message);
}
catch (Exception ex)
{
var processorType = _producer.Descriptor.StateMachineType;
_log.Error(ex, "Saga {saga} {id} raised an error on {@message}", processorType, Id, message);
var fault = Fault.NewGeneric(message, ex, processorType, Id);
var metadata = messageMetadata.CreateChild(fault.SagaId, _exceptionOnTransit);
Publisher.Publish(fault, metadata);
return;
}
var stateChange = ProcessSagaStateChange(messageMetadata);
ProcessSagaCommands(messageMetadata);
}
protected override void OnReceive(object message)
{
try
{
var messageWithMetadata = message as IMessageMetadataEnvelop;
if (messageWithMetadata != null)
{
_group.Project(messageWithMetadata.Message, messageWithMetadata.Metadata);
}
else
{
_group.Project(message, MessageMetadata.Empty());
}
}
catch (MessageProcessException ex)
{
_log.Error(ex, "Handler actor raised an error on message process: {@Message}", message);
var withMetadata = message as IMessageMetadataEnvelop;
if (withMetadata == null)
{
var fault = Fault.NewGeneric(message, ex.InnerException, ex.Type, GetSagaId(message));
_publisher.Publish(fault);
}
else
{
var fault = Fault.NewGeneric(withMetadata.Message, ex.InnerException, ex.Type, GetSagaId(message));
var metadata = withMetadata.Metadata.CreateChild(Guid.Empty,
new ProcessEntry(Self.Path.Name,
"publishing fault",
"message process casued an error"));
_publisher.Publish(fault, metadata);
}
}
}
