public MessageContext(MessageMetaData meta, IEndpoint endpoint, MessagingService messagingService, MessageTypeProperties props = null) { MetaData = meta; Endpoint = endpoint; MessagingService = messagingService; Props = props; }
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)); }
public Task SendSynchronously(IIntegrationCommand command, MessageMetaData metaData = null) { metaData = metaData ?? new MessageMetaData(); var endpoint = MessagingMap.FindEndpoint(command); _setReplyTo(endpoint, command, metaData); return(Dispatch(command, metaData)); }
public Task SendSynchronously(string messageTypeIdenfifier, byte[] command, MessageMetaData metaData = null) { metaData = metaData ?? new MessageMetaData(); var endpoint = MessagingMap.FindEndpoint(messageTypeIdenfifier); _setReplyTo(endpoint, null, metaData); return(Dispatch(new WrappedCommand(messageTypeIdenfifier, command), metaData, endpoint)); }
/************ 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)); }
/// <summary> /// Send a serialized message to an endpoint bypassing the outbound pipeline /// useful for services relay messages like the outbox ///</summary> public Task DispatchCore(string messageTypeIdentifier, byte[] message, MessageMetaData metaData, IEndpoint endpoint) { if (message == null) { throw new ArgumentNullException(nameof(message)); } if (endpoint == null) { throw new ArgumentNullException(nameof(endpoint)); } return(endpoint.Dispatch(messageTypeIdentifier, message, metaData)); }
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 void PopulateForReplyTo(MessageMetaData commandMetaData) { if (commandMetaData == null) { return; } if (this.SessionId == null) { this.SessionId = commandMetaData.SessionId; } if (this.CorrelationId == null) { this.CorrelationId = commandMetaData.CorrelationId; } }
/// <summary> /// Send a serialized message to an endpoint bypassing the outbound pipeline /// useful for services relay messages like the outbox /// </summary> /// <param name="messageTypeIdentifier"></param> /// <param name="message"></param> /// <param name="metaData"></param> /// <param name="endpointName"></param> /// <returns></returns> public Task DispatchCore(string messageTypeIdentifier, byte[] message, MessageMetaData metaData, string endpointName, bool isTransient = false) { var endpoint = endpointName != null?MessagingMap.FindEndpointByName(endpointName) : MessagingMap.FindEndpoint(messageTypeIdentifier); if (endpoint == null) { throw new ApplicationException($"Unable to dispatch message. Endpoint not found. MessageTypeIdentifier: {messageTypeIdentifier}. Endpoint: {endpointName}"); } if (isTransient && metaData != null) { if (metaData.SkipTransientDispatch) { throw new ApplicationException($"Unable to dispatch transient message. SkipTransient was set to True. MessageTypeIdentifier: {messageTypeIdentifier}. Endpoint: {endpointName}"); } if (metaData.DispatchDelay.HasValue && !endpoint.SupportsDelayedDispatch) { throw new ApplicationException($"Unable to dispatch transient message. Delay not supported by transport. MessageTypeIdentifier: {messageTypeIdentifier}. Endpoint: {endpointName}"); } } return(DispatchCore(messageTypeIdentifier, message, metaData, endpoint)); }
public virtual Task Dispatch(string messageTypeIdenfifier, byte[] message, MessageMetaData metaData = null) { return(Transport.Dispatch(messageTypeIdenfifier, message, this, metaData)); }
object ISaga.FindKey(IIntegrationMessage message, MessageMetaData meta) => FindKey(message, meta);
/// <summary> /// Send command using the configured outbox /// </summary> /// <param name="command"></param> /// <param name="metaData"></param> /// <returns></returns> public Task Send(IIntegrationCommand command, MessageMetaData metaData = null) { return(_messagingService.Send(command, _outbox, metaData)); }
/// <summary> /// Publish event using a preserialized form of the event using the configured outbox /// the outbound message filter pipeline will still be used /// </summary> /// <param name="messageTypeIdenfier"></param> /// <param name="event"></param> /// <param name="options"></param> /// <returns></returns> public Task Publish(string messageTypeIdenfier, byte[] @event, MessageMetaData options = null) { return(_messagingService.Publish(messageTypeIdenfier, @event, _outbox, options)); }
/// <summary> /// Send a preserialized Command skipping the outbox, the outbound message filter pipeline will still be honored /// </summary> /// <param name="messageTypeIdenfier"></param> /// <param name="command"></param> /// <param name="options"></param> /// <returns></returns> public Task SendSynchronously(string messageTypeIdenfier, byte[] command, MessageMetaData options = null) { return(_messagingService.SendSynchronously(messageTypeIdenfier, command, options)); }
public TransportMessage(string messageTypeIdentifier, byte[] data, MessageMetaData meta) { this.MessageTypeIdentifier = messageTypeIdentifier; this.Data = data; this.MetaData = meta; }
public Task Reply(IIntegrationReply reply, MessageMetaData replyMetaData = null) { var replyToEndpoint = this.GetEndpointForReply(); return(MessagingService.Reply(reply, replyToEndpoint, this.OutboxSession, replyMetaData, this.MetaData)); }
public virtual void SetReplyToForCommand(IIntegrationCommand command, MessageMetaData meta) { Transport.SetReplyToForCommand(this, command, meta); }
private void _setReplyTo(IEndpoint commandEndpoint, IIntegrationCommand command, MessageMetaData commandMeta) { if (commandMeta == null) { throw new InvalidOperationException("Command cannot be sent. Unable to set replyTo on null MessageMetaData"); } if (!String.IsNullOrEmpty(commandMeta.ReplyTo)) { return; } if (!String.IsNullOrEmpty(commandMeta.ReplyToEndpointName)) { var replyToEndpoint = MessagingMap.FindEndpointByName(commandMeta.ReplyToEndpointName); replyToEndpoint.SetReplyToForCommand(command, commandMeta); return; } else if (MessagingMap.DefaultReplyToEndpoint != null) { MessagingMap.DefaultReplyToEndpoint.SetReplyToForCommand(command, commandMeta); return; } throw new InvalidOperationException("Command cannot be sent because replyTo endpoint could not be determined"); }
public Task Publish(IIntegrationEvent @event, IOutboxSession outbox, MessageMetaData metaData = null) { var endpoint = MessagingMap.FindEndpoint(@event); return(Dispatch(@event, metaData, outbox)); }
/// <summary> /// Send Command skipping the outbox, the outbound message filter pipeline will still be honored /// </summary> /// <param name="command"></param> /// <param name="options"></param> /// <returns></returns> public Task SendSynchronously(IIntegrationCommand command, MessageMetaData options = null) { return(_messagingService.SendSynchronously(command, options)); }
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)); }
/// <summary> /// Publish an event using the configured outbox /// </summary> /// <param name="event"></param> /// <param name="options"></param> /// <returns></returns> public Task Publish(IIntegrationEvent @event, MessageMetaData options = null) { return(_messagingService.Publish(@event, _outbox, options)); }
public Task PublishSynchronously(IIntegrationEvent @event, MessageMetaData metaData = null) { var endpoint = MessagingMap.FindEndpoint(@event); return(Dispatch(@event, metaData)); }
/// <summary> /// Publish Event skipping the outbox, the outbound message filter pipeline will still be honored /// </summary> /// <param name="event"></param> /// <param name="options"></param> /// <returns></returns> public Task PublishSynchronously(IIntegrationEvent @event, MessageMetaData options = null) { return(_messagingService.PublishSynchronously(@event, options)); }
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)); }
/// <summary> /// Send command using a preserialized form of the command using the configured outbox /// the outbound message filter pipeline will still be used /// </summary> /// <param name="messageTypeIdenfier"></param> /// <param name="command"></param> /// <param name="options"></param> /// <returns></returns> public Task Send(string messageTypeIdenfier, byte[] command, MessageMetaData options = null) { return(_messagingService.Send(messageTypeIdenfier, command, _outbox, options)); }
public K FindKey(IIntegrationMessage message, MessageMetaData meta) { return(_keyMappers[message.GetType()].Invoke(message, meta)); }