public Task Publish(string messageTypeIdenfifier, byte[] @event, IOutboxSession outbox, MessageMetaData metaData = null)
{
metaData = metaData ?? new MessageMetaData();
var endpoint = MessagingMap.FindEndpoint(messageTypeIdenfifier);
return(Dispatch(new WrappedCommand(messageTypeIdenfifier, @event), metaData, endpoint, outbox));
}
public Task Send(string messageTypeIdenfifier, byte[] command, IOutboxSession outbox, MessageMetaData metaData = null)
{
metaData = metaData ?? new MessageMetaData();
var endpoint = MessagingMap.FindEndpoint(messageTypeIdenfifier);
_setReplyTo(endpoint, null, metaData);
return(Dispatch(new WrappedCommand(messageTypeIdenfifier, command), metaData, endpoint, outbox));
}
/************ Message Dispatching ***********/
public Task Send(IIntegrationCommand command, IOutboxSession outbox, MessageMetaData metaData = null)
{
metaData = metaData ?? new MessageMetaData();
var endpoint = MessagingMap.FindEndpoint(command);
_setReplyTo(endpoint, command, metaData);
return(Dispatch(command, metaData, outbox));
}
public MessageDispatcherTests(MessageDispatcherTests.Fixture fixture)
{
this._fixture = fixture;
this.FakeServiceFactory = A.Fake <IServiceFactory>();
this.FakeOutboxSession = A.Fake <IOutboxSession>();
this.FakeEndpoint = A.Fake <IEndpoint>();
var fakeOutbox = A.Fake <IOutbox>();
this.MessagingService = new MessagingService(fakeOutbox, this.FakeServiceFactory, null, null);
}
public MessagingClient(MessagingService messagingService, IOutboxSession outbox)
{
_messagingService = messagingService;
_outbox = outbox;
}
public Task Dispatch(IIntegrationMessage message, MessageMetaData metaData, IEndpoint endpoint, IOutboxSession outboxSession = null)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
OutboundMessagePipeline messagePipeline = null;
if (_endpointOutboundPipeline.ContainsKey(endpoint))
{
messagePipeline = _endpointOutboundPipeline[endpoint];
}
else
{
messagePipeline = new OutboundMessagePipeline(endpoint.Settings.OutboundIntegrationFilters, endpoint.Settings.OutboundTransportFilters);
_endpointOutboundPipeline[endpoint] = messagePipeline;
}
var resultContext = messagePipeline.Process(new IntegrationMessageFilterContext(message, metaData, endpoint, FilterDirection.Outbound, null));
if (outboxSession != null)//dispatch through the outbox
{
OutboxDispatchOptions options = new OutboxDispatchOptions()
{
};
if (metaData != null)
{
if (metaData.DispatchDelay.HasValue && !endpoint.SupportsDelayedDispatch)
{
options.Delay = metaData.DispatchDelay;
options.SkipTransientDispatch = true; // for safety because we set delay
}
else
{
options.SkipTransientDispatch = metaData.SkipTransientDispatch;
}
options.ExpiresAtUtc = metaData.ExpiresAtUtc;
}
return(outboxSession.Dispatch(message.MessageType, resultContext.TransportMessage.Data, resultContext.TransportMessage.MetaData, endpoint, options));
}
//dispatch to the endpoint
return(DispatchCore(message.MessageType, resultContext.TransportMessage.Data, resultContext.TransportMessage.MetaData, endpoint));
}
public Task Dispatch(IIntegrationMessage message, MessageMetaData metaData = null, IOutboxSession outbox = null)
{
var endpoint = MessagingMap.FindEndpoint(message) ??
throw new ApplicationException($"Unable to dispatch message. Type: {message.GetType()} Message Type: {message.MessageType}");
return(Dispatch(message, metaData, endpoint, outbox));
}
internal Task Reply(IIntegrationReply reply, IEndpoint endpoint, IOutboxSession outbox, MessageMetaData metaData = null, MessageMetaData commandMetaData = null)
{
metaData = metaData ?? new MessageMetaData();
metaData.PopulateForReplyTo(commandMetaData);
return(Dispatch(reply, metaData, endpoint, outbox));
}
public Task Publish(IIntegrationEvent @event, IOutboxSession outbox, MessageMetaData metaData = null)
{
var endpoint = MessagingMap.FindEndpoint(@event);
return(Dispatch(@event, metaData, outbox));
}
