public async Task <IWaitResults> Execute <T>(T command, IMessageMetadata metadata) where T : ICommand { _waiter.ExpectBuilder.Or <IFault <T> >(f => f.Message.Id == command.Id); _waiter.ExpectBuilder.Or <Fault <T> >(f => f.Message.Id == command.Id); _waiter.ExpectBuilder.Or <IMessageMetadataEnvelop <IFault <T> > >(f => f.Message.Message.Id == command.Id); _waiter.ExpectBuilder.Or <IMessageMetadataEnvelop <Fault <T> > >(f => f.Message.Message.Id == command.Id); var task = _waiter.Start(); Executor.Execute(command, metadata); var res = await task; if (!_failOnFaults) { return(res); } var faults = res.All.OfType <IMessageMetadataEnvelop <IFault> >().ToArray(); if (faults.Any()) { throw new AggregateException(faults.Select(f => f.Message.Exception)); } return(res); }
public NicoCommentViewModel(NicoSitePlugin.INicoInfo info, IMessageMetadata metadata, IMessageMethods methods, IConnectionStatus connectionStatus, IOptions options) : this(info as NicoSitePlugin.INicoMessage, metadata, methods, connectionStatus, options) { _nameItems = info.NameItems; MessageItems = info.CommentItems; PostTime = info.PostTime; }
public async Task Execute(ICommand command, IMessageMetadata metadata = null, CommandConfirmationMode confirmationMode = CommandConfirmationMode.Projected) { var envelopedCommand = new MessageMetadataEnvelop(command, metadata ?? CreateEmptyCommandMetadata(command)); if (confirmationMode == CommandConfirmationMode.None) { _commandExecutorActor.Tell(envelopedCommand); return; } var inbox = Inbox.Create(_system); _commandExecutorActor.Tell(envelopedCommand, inbox.Receiver); var msg = await inbox.ReceiveAsync(_defaultTimeout); if (CheckMessage(confirmationMode, msg)) { return; } msg = await inbox.ReceiveAsync(_defaultTimeout); if (CheckMessage(confirmationMode, msg)) { return; } throw new TimeoutException("Command execution took to long"); }
/// <summary> /// Send metadata to create a message /// </summary> public string Send(IMessageMetadata metadata, XmlDocument body) { try { STARTLibrary.accesspointService.Create messageBody = new STARTLibrary.accesspointService.Create(); messageBody.Any = new XmlElement[] { body.DocumentElement }; var request = new STARTLibrary.accesspointService.CreateRequest { MessageIdentifier = metadata.MessageIdentifier, ChannelIdentifier = metadata.ChannelIdentifier, RecipientIdentifier = metadata.RecipientIdentifier, SenderIdentifier = metadata.SenderIdentifier, DocumentIdentifier = metadata.DocumentIdentifier, ProcessIdentifier = metadata.ProcessIdentifier, Create = messageBody }; return(common.Utilities.CallCreate(resourceFactory, thisUri, smlDomain, assuranceLevel, request)); } catch (Exception) { throw help.MakePeppolException("bden:ServerError", "ServerError"); } }
public async Task <IWaitResults> Publish(object message, IMessageMetadata metadata = null) { var task = _waiter.Start(); _publisher.Publish(message, metadata ?? MessageMetadata.Empty()); return(await task); }
public NicoCommentViewModel(NicoSitePlugin.INicoInfo info, IMessageMetadata metadata, IMessageMethods methods, IConnectionStatus connectionStatus, IOptions options) : this(info as NicoSitePlugin.INicoMessage, metadata, methods, connectionStatus, options) { //_nameItems = MessagePartFactory.CreateMessageItems(info.UserName); MessageItems = MessagePartFactory.CreateMessageItems(info.Text); PostTime = info.PostedAt.ToString("HH:mm:ss"); }
private async Task ProcessCommand(ICommand command, JobDataMap jobDataMap, IMessageMetadata metadata, JobKey jobKey) { var options = Get <ExecutionOptions>(jobDataMap, ExecutionOptionsKey); if (options.SuccesEventType == null) { throw new OptionsNotFilledException("options do not have SuccessEventType for key " + jobKey); } var commandMetadata = metadata.CreateChild(command.Id, new ProcessEntry(nameof(QuartzJob), PassingCommandToExecutor, CommandRaiseTime)); //waiting domain event by correlation id await _executor.Prepare(command, commandMetadata) .Expect(options.SuccesEventType) .Execute(options.Timeout, true); _quartzLogger.Information("job {key} succeed", jobKey.Name); var successMetadata = commandMetadata.CreateChild(Guid.NewGuid().ToString(), new ProcessEntry(nameof(QuartzJob), "Publishing success notification", "Job execution completed succesfully. Command executed and confirmed.")); var jobSucceeded = new JobSucceeded(jobKey.Name, jobKey.Group, command); _publisher.Publish(jobSucceeded, successMetadata); }
public ScheduleMessage(DomainEvent eventToSchedule, ScheduleKey key, DateTime runAt, IMessageMetadata eventMetadata = null) { Event = eventToSchedule; Key = key; RunAt = runAt; EventMetadata = eventMetadata; }
public async Task PublishAsync(TType entry, IMessageMetadata messageMeta = null) { string messageData = (typeof(TType) == typeof(string)) ? entry as string : _serializationUtility.Serialize(entry); var message = new BrokeredMessage(messageMeta.MessageEncoding.GetBytes(messageData)); if (messageMeta != null && !string.IsNullOrEmpty(messageMeta.CorrelationId)) { message.CorrelationId = messageMeta.CorrelationId; } if (messageMeta != null && !string.IsNullOrEmpty(messageMeta.MessageId)) { message.MessageId = messageMeta.MessageId; } if (messageMeta != null && !string.IsNullOrEmpty(messageMeta.MessagePart)) { message.UserProperties.Add("messagePart", messageMeta.MessagePart); } if (messageMeta != null && !string.IsNullOrEmpty(messageMeta.MessageType)) { message.UserProperties.Add("messageType", messageMeta.MessageType); } await _topicClient.SendAsync(message); }
public static MessageMetadata CreateFrom(string messageId, IMessageMetadata existedMessage) { return(new MessageMetadata(messageId, existedMessage.CorrelationId, existedMessage.MessageId)); }
public ScheduleCommand(Command command, ScheduleKey key, ExtendedExecutionOptions options, IMessageMetadata commandMetadata = null) { Command = command; Key = key; Options = options; CommandMetadata = commandMetadata; }
/// <summary> /// Boring code that enforce correct message and metadata pairs for events, commands and ordinary messages /// </summary> public static IMessageEnvelope CreateEnvelope(IMessage message, IMessageMetadata messageMetadata) { if (message == null) { throw new ArgumentNullException("message"); } if (message is IEvent) { messageMetadata = messageMetadata ?? new EventMetadata(); if (!(messageMetadata is IEventMetadata)) { throw new Exception("Event message doesn't have EventMetadata."); } return(new EventEnvelope((IEvent)message, (IEventMetadata)messageMetadata)); } if (message is ICommand) { messageMetadata = messageMetadata ?? new CommandMetadata(); if (!(messageMetadata is ICommandMetadata)) { throw new Exception("Command message doesn't have CommandMetadata."); } return(new CommandEnvelope((ICommand)message, (ICommandMetadata)messageMetadata)); } return(new MessageEnvelope(message, messageMetadata ?? new MessageMetadata())); }
public Task Handle(BalanceChangedEvent_V1 msg, IMessageMetadata metadata) { _publisher.Publish(new BalanceAggregateChangedEventNotification { AggregateId = msg.SourceId }); return(Task.CompletedTask); }
private void ProjectMessage <TMessage, THandler>(object msg, IMessageMetadata metadata) where THandler : IHandler <TMessage> where TMessage : class { var message = msg as TMessage; if (message == null) { throw new UnknownMessageException(); } try { var handler = _locator.Resolve <THandler>(); var withMetadata = handler as IHandlerWithMetadata <TMessage>; if (withMetadata != null) { withMetadata.Handle(message, metadata); } else { handler.Handle(message); } } catch (Exception ex) { throw new MessageProcessException(typeof(THandler), ex); } }
public void Publish(object msg, IMessageMetadata metadata) { _local.Publish(msg); var messageMetadataEnvelop = MessageMetadataEnvelop.NewGeneric(msg, metadata); _remoteSubscriber.Ask <PublishAck>(new Publish(messageMetadataEnvelop), _timeout).Wait(); }
public Task Handle(FutureEventCanceledEvent evt, IMessageMetadata metadata) { var key = CreateScheduleKey(evt.FutureEventId, evt.SourceId, evt.SourceName); return(_schedulerActorRef.Ask <object>(new Unschedule(key)) .ContinueWith(t => { switch (t.Result) { case Unscheduled unsched: break; case Failure f: { _logger.Error(f.Exception, "Error occured during unscheduling event"); break; } default: { _logger.Error("Unexpected message received during unscheduling event confirmation wait: {msg}", t.Result); break; } } })); }
public void Setup() { var options = new DynamicOptions() { IsEnabled = true, }; var host = CreatePluginHost(options); var model = CreateModel(options, host); var vm = CreateViewModel(model); _vm = vm; var messageMetadataMock = new Mock <IMessageMetadata>(); messageMetadataMock.Setup(m => m.User).Returns(new UserTest("1")); messageMetadataMock.Setup(x => x.SiteContextGuid).Returns(Guid.NewGuid()); var messageMetadata = messageMetadataMock.Object; _messageMetadata = messageMetadata; var plugin = CreatePlugin(vm, model, options); _plugin = plugin; plugin.Host = host; plugin.OnLoaded(); }
private object[] ProcessSagaStateChange(IMessageMetadata mutatorMessageMetadata) { var stateChangeEvents = State.GetUncommittedEvents().Cast <DomainEvent>().ToArray(); int totalEvents = stateChangeEvents.Length; int persistedEvents = 0; PersistAll(stateChangeEvents, e => { var metadata = mutatorMessageMetadata.CreateChild(e.SourceId, new ProcessEntry(Self.Path.Name, "Saga state event published", "Saga changed state")); Publisher.Publish(e, metadata); NotifyWatchers(new Persisted(e)); //should save snapshot only after all messages persisted as state was already modified by all of them if (++persistedEvents == totalEvents) { TrySaveSnapshot(stateChangeEvents); } }); State.ClearUncommittedEvents(); return(stateChangeEvents); }
/// <summary> /// Copy message metadata to another object, that implements IMessageMetadata /// </summary> public virtual void Copy(IMessageMetadata to) { to.MessageId = MessageId; to.TriggerMessageId = TriggerMessageId; to.MessageTag = MessageTag; to.CreatedUtc = CreatedUtc; }
public void SetMessage(ISiteMessage message, IMessageMetadata messageMetadata) { foreach (var plugin in _plugins) { plugin.OnMessageReceived(message, messageMetadata); } }
public async Task Handle(AccountWithdrawal msg, IMessageMetadata metadata = null) { using (var context = _contextFactory()) { var account = await context.Accounts.FindAsync(msg.SourceId); var initialAmount = account.Amount; account.LastModified = msg.CreatedTime; account.Amount -= msg.Amount.Amount; var transaction = new AccountTransaction { AccountId = msg.SourceId, ChangeAmount = msg.Amount.Amount, Created = msg.CreatedTime, Currency = msg.Amount.CurrencyCode.ToString(), InitialAmount = initialAmount, NewAmount = account.Amount, Operation = AccountOperations.Withdrawal, TransactionId = msg.ChangeId }; context.TransactionHistory.Add(transaction); await context.SaveChangesAsync(); } }
public IPacket CreatePacket(IMessage message, IMessageMetadata metadata) { var envelope = new PacketBuilder(_messageFactory.TypeToTagResolver, _packetSerializer); envelope.AddMessage(message, metadata); return(envelope.Build()); }
public ProcessTransited(IReadOnlyCollection <ICommand> producedCommands, IMessageMetadata metadata, ProcessEntry procesTransitEntry, IProcessState newProcessState) : base(producedCommands, metadata) { ProcessTransitEntry = procesTransitEntry; NewProcessState = newProcessState; }
public CommandWaiter(TCommand command, IMessageMetadata commandMetadata, ActorSystem system, IActorTransport transport, TimeSpan defaultTimeout) : base(system, transport, defaultTimeout) { _expectBuilder = new CommandExpectBuilder <TCommand>(command, commandMetadata, transport, this); }
public ICommandWaiter Prepare <T>(T cmd, IMessageMetadata metadata = null) where T : ICommand { if (!IsConnected) { throw new NotConnectedException(); } return(_commandExecutor.Prepare(cmd, metadata)); }
public static IMessageMetadataEnvelop NewGeneric(object msg, IMessageMetadata metadata) { var msgType = msg.GetType(); var methodOpenType = typeof(MessageMetadataEnvelop).GetMethod(nameof(New)); var method = methodOpenType.MakeGenericMethod(msgType); return((IMessageMetadataEnvelop)method.Invoke(null, new[] { msg, metadata })); }
public async Task Execute(ICommand command, IMessageMetadata metadata = null, CommandConfirmationMode mode = CommandConfirmationMode.Projected) { if (!IsConnected) { throw new NotConnectedException(); } await _commandExecutor.Execute(command, metadata, mode); }
public Task <IWaitResult> SendToProcessManagers(IFault message, IMessageMetadata metadata = null) { var task = _waiter.Start(); _commandPipe.ProcessesPipeActor.Tell(new MessageMetadataEnvelop <IFault>(message, metadata ?? MessageMetadata.Empty)); return(task); }
public NicoCommentViewModel(NicoSitePlugin.INicoEmotion item, IMessageMetadata metadata, IMessageMethods methods, IConnectionStatus connectionStatus, IOptions options) : this(item as NicoSitePlugin.INicoMessage, metadata, methods, connectionStatus, options) { //_nameItems = MessagePartFactory.CreateMessageItems(item.UserName); MessageItems = MessagePartFactory.CreateMessageItems(item.Content); PostTime = item.PostedAt.ToString("HH:mm:ss"); Info = "エモーション"; }
public McvBigoCommentViewModel(IBigoComment comment, IMessageMetadata metadata, IMessageMethods methods, IConnectionStatus connectionStatus, IOptions options) : base(metadata, methods, connectionStatus, options) { MessageItems = Common.MessagePartFactory.CreateMessageItems(comment.Message); _nameItems = Common.MessagePartFactory.CreateMessageItems(comment.Name); //Id = comment.Id; PostTime = comment.PostedAt.ToString("HH:mm:ss"); }
public CommandConditionBuilder(TCommand command, IMessageMetadata commandMetadata, IActorRef executorActorRef) { _commandMetadata = commandMetadata; _executorActorRef = executorActorRef; _command = command; }
/// <summary> /// Copy event metadata to another object, that implements IEventMetadata /// </summary> public override void Copy(IMessageMetadata to) { base.Copy(to); var eventMetadata = to as ICommandMetadata; if (eventMetadata == null) return; eventMetadata.ReceiverId = ReceiverId; eventMetadata.ExpectedVersion = ExpectedVersion; }
/// <summary> /// Copy event metadata to another object, that implements IEventMetadata /// </summary> public override void Copy(IMessageMetadata to) { base.Copy(to); var eventMetadata = to as IEventMetadata; if (eventMetadata == null) return; eventMetadata.SenderId = SenderId; eventMetadata.StreamVersion = StreamVersion; eventMetadata.TransitionSequence = TransitionSequence; }
public MessageEnvelope(IMessage message, IMessageMetadata metadata) { Metadata = metadata; Message = message; }