public async Task Process(IMessageMetadataEnvelop envelop)
{
foreach (var p in _processorListCatalog.Get(envelop.Message))
{
await p.Process(envelop);
}
}
public virtual void Handle(IMessageMetadataEnvelop <TMessage> msg)
{
_monitor.IncrementMessagesReceived();
_log.Trace("Handler actor got message: {@Message}", msg);
try
{
var handlerWithMetadata = _handler as IHandlerWithMetadata <TMessage>;
if (handlerWithMetadata != null)
{
handlerWithMetadata.Handle(msg.Message, msg.Metadata);
}
else
{
_handler.Handle(msg.Message);
}
}
catch (Exception e)
{
_log.Error(e, "Handler actor raised an error on message process: {@Message}", msg);
var metadata = msg.Metadata.CreateChild(Guid.Empty,
new ProcessEntry(typeof(THandler).Name, MessageHandlingStatuses.PublishingFault, MessageHandlingStatuses.MessageProcessCasuedAnError));
var fault = Fault.New(msg.Message, e, GetSagaId(msg.Message), typeof(THandler));
_publisher.Publish(fault, metadata);
}
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new InflateNewBallonCommand(1, Guid.NewGuid().ToString());
_commandMetadata = MessageMetadata.New(_command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(_command, _commandMetadata)
.Expect <BalloonCreated>()
.And <BalloonCreatedNotification>()
.Execute();
_answer = res.MessageWithMetadata <BalloonCreatedNotification>();
_aggregateEvent = res.MessageWithMetadata <BalloonCreated>();
//Result_contains_metadata()
Assert.NotNull(_answer.Metadata);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <BalloonCreatedNotification>(_answer.Message);
//Result_message_has_expected_id()
Assert.Equal(_command.AggregateId, _answer.Message.BallonId);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(_aggregateEvent.Metadata.MessageId, _answer.Metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(_commandMetadata.CorrelationId, _answer.Metadata.CorrelationId);
// Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, _answer.Metadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = _answer.Metadata.History.Steps.First();
//Assert.Equal(nameof(BalloonCreatedNotificator), step.Who);
//Assert.Equal(BalloonCreatedNotificator.Why, step.Why);
//Assert.Equal(BalloonCreatedNotificator.MessageProcessed, step.What);
}
public void Clear()
{
processingEnvelop = null;
pendingState = default(TState);
producedCommands = new ICommand[] { };
processingMessageSender = null;
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new PlanTitleChangeCommand(1, Guid.NewGuid().ToString());
_commandMetadata = MessageMetadata.New(_command.Id, Guid.NewGuid().ToString(), null);
var res = await Node.Prepare(_command, _commandMetadata)
.Expect <BalloonTitleChanged>()
.Execute();
_answer = res.MessageWithMetadata <BalloonTitleChanged>();
//Result_contains_metadata()
Assert.NotNull(_answer.Metadata);
//Result_contains_message()
Assert.NotNull(_answer.Message);
//Result_message_has_expected_type()
Assert.IsAssignableFrom <BalloonTitleChanged>(_answer.Message);
//Result_message_has_expected_id()
Assert.Equal(_command.AggregateId, _answer.Message.SourceId);
//Result_message_has_expected_value()
Assert.Equal(_command.Parameter.ToString(), _answer.Message.Value);
//Result_metadata_has_command_id_as_casuation_id()
Assert.Equal(_command.Id, _answer.Metadata.CasuationId);
//Result_metadata_has_correlation_id_same_as_command_metadata()
Assert.Equal(_commandMetadata.CorrelationId, _answer.Metadata.CorrelationId);
//Result_metadata_has_processed_history_filled_from_aggregate()
//Assert.Equal(1, _answer.Metadata.History?.Steps.Count);
////Result_metadata_has_processed_correct_filled_history_step()
//var step = _answer.Metadata.History.Steps.First();
//Assert.Equal(AggregateActorName.New<Balloon>(_command.AggregateId)
// .Name,
// step.Who);
//Assert.Equal(AggregateActorConstants.CommandExecutionCreatedAnEvent, step.Why);
//Assert.Equal(AggregateActorConstants.PublishingEvent, step.What);
}
private static string GetMessageId(IMessageMetadataEnvelop processingEnvelop)
{
switch (processingEnvelop.Message)
{
case IHaveId e: return(e.Id);
case IFault <ICommand> e: return(e.Message.Id);
}
throw new CannotGetProcessIdFromMessageException(processingEnvelop);
}
public void StartNewExecution(TState pendingState, IMessageMetadataEnvelop msg, IActorRef sender)
{
if (IsInitializing)
{
throw new InvalidOperationException("Cannot start new execution while initializing");
}
PendingState = pendingState ?? throw new ProcessStateNullException();
ProcessingMessage = msg;
ProcessingMessageSender = sender;
}
public async Task When_execute_aggregate_command_with_fault_and_metadata()
{
_command = new AlwaysFaultAsyncCommand(Guid.NewGuid(), TimeSpan.FromMilliseconds(50));
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = await GridNode.NewCommandWaiter(null, false)
.Expect <SampleAggregateCreatedEvent>()
.Create()
.Execute(_command, _commandMetadata);
_answer = res.Message <IMessageMetadataEnvelop <IFault <AlwaysFaultAsyncCommand> > >();
}
private static string ExtractId(IMessageMetadataEnvelop env)
{
switch (env.Message)
{
case IFault f: return(f.ProcessId);
case IHaveProcessId p: return(p.ProcessId);
case ProcessRedirect r: return(r.ProcessId);
}
throw new CannotGetProcessIdFromMessageException(env.Message);
}
public async Task When_execute_aggregate_command_with_fault_and_metadata()
{
_command = new ScheduleErrorInFutureCommand(DateTime.Now.AddSeconds(0.5), Guid.NewGuid(), "12", 1);
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = await GridNode.PrepareCommand(_command, _commandMetadata)
.Expect <JobFailed>()
.And <IFault <RaiseScheduledDomainEventCommand> >()
.Execute(TimeSpan.FromSeconds(30));
_schedulingCommandFault = res.Message <IMessageMetadataEnvelop <IFault <RaiseScheduledDomainEventCommand> > >();
_jobFailedEnvelop = res.Message <IMessageMetadataEnvelop <JobFailed> >();
}
public void When_execute_aggregate_command_with_metadata()
{
_command = new AsyncMethodCommand(1, Guid.NewGuid());
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = GridNode.NewCommandWaiter()
.Expect <IMessageMetadataEnvelop <SampleAggregateChangedEvent> >()
.Create()
.Execute(_command, _commandMetadata)
.Result;
_answer = res.Message <IMessageMetadataEnvelop <SampleAggregateChangedEvent> >();
}
public async Task When_publishing_start_message()
{
SagaId = Guid.NewGuid();
_gotTiredEvent = new GotTiredEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), SagaId);
_gotTiredEventMetadata = new MessageMetadata(_gotTiredEvent.SourceId, BusinessDateTime.UtcNow, Guid.NewGuid(), Guid.NewGuid());
var res = await GridNode.NewDebugWaiter(TimeSpan.FromHours(5))
.Expect <IMessageMetadataEnvelop <MakeCoffeCommand> >()
.Create()
.Publish(_gotTiredEvent, _gotTiredEventMetadata);
_answer = res.Message <IMessageMetadataEnvelop <MakeCoffeCommand> >();
}
public async Task When_execute_aggregate_command_with_fault_and_metadata()
{
_command = new ScheduleEventInFutureCommand(DateTime.Now.AddMilliseconds(20), Guid.NewGuid(), "12");
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = await GridNode.NewCommandWaiter(null, false)
.Expect <IMessageMetadataEnvelop <TestDomainEvent> >()
.And <IMessageMetadataEnvelop <JobSucceeded> >()
.Create()
.Execute(_command, _commandMetadata);
_answer = res.Message <IMessageMetadataEnvelop <TestDomainEvent> >();
_jobSucced = res.Message <IMessageMetadataEnvelop <JobSucceeded> >();
}
public async Task When_execute_aggregate_command_with_metadata()
{
_command = new CreateSampleAggregateCommand(1, Guid.NewGuid());
_commandMetadata = new MessageMetadata(_command.Id, BusinessDateTime.Now, Guid.NewGuid());
var res = await GridNode.NewCommandWaiter(null, false)
.Expect <IMessageMetadataEnvelop <SampleAggregateCreatedEvent> >()
.And <IMessageMetadataEnvelop <IFault <SampleAggregateCreatedEvent> > >()
.Create()
.Execute(_command, _commandMetadata);
_answer = res.Message <IMessageMetadataEnvelop <IFault <SampleAggregateCreatedEvent> > >();
_aggregateEvent = res.Message <IMessageMetadataEnvelop <SampleAggregateCreatedEvent> >();
}
private void TransitingProcessBehavior()
{
IMessageMetadataEnvelop processingEnvelop = null;
IReadOnlyCollection <ICommand> producedCommands = null;
IActorRef processingMessageSender = null;
Receive <IMessageMetadataEnvelop>(messageEnvelop =>
{
_log.Debug("Transiting process by {@message}", messageEnvelop);
processingEnvelop = messageEnvelop;
processingMessageSender = Sender;
var pendingState = (TState)State.Clone();
Behavior.Become(() => AwaitingTransitionConfirmationBehavior(pendingState), nameof(AwaitingTransitionConfirmationBehavior));
Process.Transit(pendingState, messageEnvelop.Message)
.PipeTo(Self);
});
void AwaitingTransitionConfirmationBehavior(TState pendingState)
{
Receive <IReadOnlyCollection <ICommand> >(transitionResult =>
{
_log.Debug("Process was transited, new state is {@state}", pendingState);
producedCommands = transitionResult;
var cmd = new SaveStateCommand <TState>(Id,
pendingState,
GetMessageId(processingEnvelop));
//will reply back with CommandExecuted
_stateAggregateActor.Tell(new MessageMetadataEnvelop <SaveStateCommand <TState> >(cmd, processingEnvelop.Metadata));
});
Receive <AggregateActor.CommandExecuted>(c =>
{
State = pendingState;
processingMessageSender.Tell(new ProcessTransited(producedCommands, processingEnvelop.Metadata,
_producedCommand,
State));
_log.Debug("Process dispatched {count} commands {@commands}", producedCommands?.Count ?? 0, producedCommands);
Behavior.Become(AwaitingMessageBehavior, nameof(AwaitingMessageBehavior));
pendingState = null;
processingMessageSender = null;
processingEnvelop = null;
producedCommands = null;
});
Receive <Status.Failure>(f => FinishWithError(processingEnvelop, processingMessageSender, f.Cause));
StashingMessagesToProcessBehavior("process is waiting for transition confirmation");
}
}
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();
}
public async Task <ProcessesTransitComplete> Process(IMessageMetadataEnvelop messageMetadataEnvelop)
{
var processors = _catalog.Get(messageMetadataEnvelop.Message);
var results = new List <object>();
foreach (var p in processors)
{
var processTransitionResult = await p.Process(messageMetadataEnvelop);
results.Add(processTransitionResult);
}
var processTransited = results.OfType <ProcessTransited>().ToArray();
if (!processTransited.Any())
{
return(ProcessesTransitComplete.NoResults);
}
return(new ProcessesTransitComplete(messageMetadataEnvelop, CreateCommandEnvelops(processTransited).ToArray()));
}
public void Clear()
{
pendingState = default(TState);
processingMessage = null;
processingMessageSender = null;
}
Task IMessageProcessor.Process(IMessageMetadataEnvelop message)
{
return(Process(message));
}
public CreateNewProcess(IMessageMetadataEnvelop message, Guid?enforcedId = null)
{
Message = message;
EnforcedId = enforcedId;
}
public MarkedHandlerExecutedMessage(string mark, IMessageMetadataEnvelop processingMessage, Exception error = null) : base(processingMessage, error)
{
Mark = mark;
}
public Task <T> Process(IMessageMetadataEnvelop message)
{
return(_processor.Ask <T>(message, _defaultTimeout));
}
protected override string GetChildActorId(IMessageMetadataEnvelop message)
{
return((message.Message as ICommand)?.AggregateId);
}
public Task Process(IMessageMetadataEnvelop message)
{
ActorRef.Tell(message);
return(Task.CompletedTask);
}
public HandlerExecuted(IMessageMetadataEnvelop processingMessage, Exception error = null)
{
ProcessingMessage = processingMessage;
Error = error;
}
protected override string GetChildActorId(IMessageMetadataEnvelop env)
{
var id = ExtractId(env);
return(string.IsNullOrEmpty(id) ? ProcessSpawnId : id);
}
public ProcessRedirect(string processId, IMessageMetadataEnvelop messageToRedirect)
{
ProcessId = processId;
MessageToRedirect = messageToRedirect;
}
protected abstract string GetChildActorId(IMessageMetadataEnvelop message);
public ProcessesTransitComplete(IMessageMetadataEnvelop initialMessage, IMessageMetadataEnvelop <ICommand>[] producedCommands)
{
InitialMessage = initialMessage;
ProducedCommands = producedCommands;
}
