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