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; }