void Invoke(LogicalMessage message)
{
var context = new SendLogicalMessageContext(null, new SendOptions(), message);
sendBehavior.Invoke(context, () => { });
}
public void Incoming_databus_properties_should_be_hydrated()
{
var propertyKey = Guid.NewGuid().ToString();
var databusKey = Guid.NewGuid().ToString();
var message = new LogicalMessage(null, new MessageWithDataBusProperty
{
DataBusProperty = new DataBusProperty<string>("not used in this test")
{
Key = propertyKey
}
}, new Dictionary<string, string> { { "NServiceBus.DataBus." + propertyKey, databusKey } }, null);
using (var stream = new MemoryStream())
{
new BinaryFormatter().Serialize(stream, "test");
stream.Position = 0;
dataBus.Stub(s => s.Get(databusKey)).Return(stream);
receiveBehavior.Invoke(new ReceiveLogicalMessageContext(null,message), ()=>{});
}
var instance = (MessageWithDataBusProperty)message.Instance;
Assert.AreEqual(instance.DataBusProperty.Value, "test");
}
public IncomingLogicalMessageContext(LogicalMessage logicalMessage, string messageId, string replyToAddress, Dictionary<string, string> headers, IBehaviorContext parentContext)
: base(messageId, replyToAddress, headers, parentContext)
{
Message = logicalMessage;
Headers = headers;
Set(logicalMessage);
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
if (returnInfo == null)
{
return;
}
if (string.IsNullOrEmpty(transportMessage.CorrelationId))
{
return;
}
if (transportMessage.Headers.ContainsKey(Headers.HttpTo) ||
transportMessage.Headers.ContainsKey(Headers.DestinationSites))
{
return;
}
transportMessage.Headers[Headers.HttpTo] = returnInfo.HttpFrom;
transportMessage.Headers[Headers.OriginatingSite] = returnInfo.OriginatingSite;
if (!transportMessage.Headers.ContainsKey(Headers.RouteTo))
{
transportMessage.Headers[Headers.RouteTo] = returnInfo.ReplyToAddress.ToString();
}
// send to be backwards compatible with Gateway 3.X
transportMessage.Headers[GatewayHeaders.LegacyMode] = returnInfo.LegacyMode.ToString();
}
void Invoke(LogicalMessage message)
{
var context = new OutgoingContext(null, new SendOptions(Address.Parse("MyEndpoint")), message);
sendBehavior.Invoke(context, () => { });
}
public OutgoingTransportContext(LogicalMessage message, TransportMessage outgoingTransportMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
: base(configuration)
{
this.Set(message);
this.Set(OutgoingTransportMessageKey, outgoingTransportMessage);
this.Set(IncomingTransportMessageKey, incomingTransportMessage);
this.Set(options);
}
public IncomingLogicalContext(LogicalMessage logicalMessage, TransportMessage message, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
this.Set(logicalMessage);
this.Set(message);
this.Set<MessageHandler>(null, ShouldBeSnapshotted.Yes);
this.Set(HandlerInvocationAbortPendingKey, false);
}
void DispatchMessageToHandlersBasedOnType(IBuilder builder, LogicalMessage toHandle, LoadedMessageHandlers loadedHandlers, BehaviorContext context)
{
foreach (var loadedHandler in loadedHandlers.GetHandlersFor(toHandle.MessageType))
{
if (loadedHandler.InvocationDisabled)
continue;
var handlerInstance = loadedHandler.Instance;
try
{
//until we have a outgoing pipeline that inherits context from the main one
if (handlerInstance is ISaga)
{
SagaContext.Current = (ISaga) handlerInstance;
}
var handlerTypeToInvoke = handlerInstance.GetType();
//for backwards compatibility (users can have registered their own factory
var factory = GetDispatcherFactoryFor(handlerTypeToInvoke, builder);
if (factory != null)
{
var dispatchers = factory.GetDispatcher(handlerTypeToInvoke, builder, toHandle.Instance).ToList();
dispatchers.ForEach(dispatch =>
{
log.DebugFormat("Dispatching message '{0}' to handler '{1}'", toHandle.MessageType, handlerTypeToInvoke);
try
{
dispatch();
}
catch (Exception e)
{
log.Warn(handlerTypeToInvoke.Name + " failed handling message.", e);
throw new TransportMessageHandlingFailedException(e);
}
});
}
else
{
loadedHandler.Invocation(handlerInstance, toHandle.Instance);
}
//for now we have to check of the chain is aborted but this will go away when we refactor the handlers to be a subpipeline
if (context.ChainAborted)
{
log.DebugFormat("Handler {0} requested downstream handlers of message {1} to not be invoked", handlerTypeToInvoke,toHandle.MessageType);
return;
}
}
finally
{
SagaContext.Current = null;
}
}
}
public ActiveSagaInstance(ISaga saga, LoadedMessageHandlers.LoadedHandler messageHandler, LogicalMessage message)
{
Instance = saga;
SagaType = saga.GetType();
MessageToProcess = message;
Handler = messageHandler;
//default the invocation to disabled until we have a entity attached
Handler.InvocationDisabled = true;
}
public void Outgoing_databus_properties_should_be_dehydrated()
{
var metadata = new MessageMetadata();
var message = new LogicalMessage(metadata, new MessageWithDataBusProperty
{
DataBusProperty = new DataBusProperty<string>("test")
}, new Dictionary<string, string>(), null);
Invoke(message);
dataBus.AssertWasCalled(
x => x.Put(Arg<Stream>.Is.Anything, Arg<TimeSpan>.Is.Equal(TimeSpan.MaxValue)));
}
public void Time_to_live_should_be_passed_on_the_databus()
{
var metadata = new MessageMetadata(timeToBeReceived: TimeSpan.FromMinutes(1));
var message = new LogicalMessage(metadata, new MessageWithExplicitTimeToLive
{
DataBusProperty = new DataBusProperty<string>("test")
}, new Dictionary<string, string>(), null);
Invoke(message);
dataBus.AssertWasCalled(
x => x.Put(Arg<Stream>.Is.Anything, Arg<TimeSpan>.Is.Equal(TimeSpan.FromMinutes(1))));
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
if (Thread.CurrentPrincipal != null && Thread.CurrentPrincipal.Identity != null && !string.IsNullOrEmpty(Thread.CurrentPrincipal.Identity.Name))
{
transportMessage.Headers[Headers.WindowsIdentityName] = Thread.CurrentPrincipal.Identity.Name;
return;
}
var windowsIdentity = WindowsIdentity.GetCurrent();
if (windowsIdentity != null)
{
transportMessage.Headers[Headers.WindowsIdentityName] = windowsIdentity.Name;
}
}
public void Should_not_blow_up()
{
var metadata = new MessageMetadata(timeToBeReceived: TimeSpan.FromDays(1));
var message = new LogicalMessage(metadata, new MessageWithNullDataBusProperty(), new Dictionary<string, string>(), null);
var context = new OutgoingContext(null,new SendOptions(Address.Parse("MyEndpoint")), message);
using (var stream = new MemoryStream())
{
new BinaryFormatter().Serialize(stream, "test");
stream.Position = 0;
sendBehavior.Invoke(context, () => { });
}
}
public virtual async Task Invoke(LogicalMessage outgoingLogicalMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
{
executingLogicalPipeline = new Queue<IOutgoingLogicalStep>(registeredlogicalPipelineSteps);
var logicalContext = new OutgoingLogicalContext(outgoingLogicalMessage, options, configuration);
await InvokeLogical(logicalContext)
.ConfigureAwait(false);
// We assume that someone in the pipeline made transport message
var outgoingTransportMessage = logicalContext.Get<TransportMessage>();
executingTransportPipeline = new Queue<IOutgoingTransportStep>(registeredTransportPipelineSteps);
var transportContext = new OutgoingTransportContext(outgoingLogicalMessage, outgoingTransportMessage, options, configuration, incomingTransportMessage);
await InvokeTransport(transportContext)
.ConfigureAwait(false);
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
if (transportMessage.Headers.ContainsKey(CorrIdHeader))
return;
var correlationIdToUse = transportMessage.CorrelationId;
Guid correlationId;
if (Guid.TryParse(correlationIdToUse, out correlationId))
{
//msmq requires the id's to be in the {guid}\{incrementing number} format so we need to fake a \0 at the end to make it compatible
correlationIdToUse += "\\0";
}
transportMessage.Headers[CorrIdHeader] = correlationIdToUse;
}
static bool IsMessageAllowedToStartTheSaga(LogicalMessage message, SagaMetadata sagaMetadata)
{
string sagaType;
if (message.Headers.ContainsKey(Headers.SagaId) &&
message.Headers.TryGetValue(Headers.SagaType, out sagaType))
{
//we want to move away from the assembly fully qualified name since that will break if you move sagas
// between assemblies. We use the fullname instead which is enough to identify the saga
if (sagaType.StartsWith(sagaMetadata.Name))
{
//so now we have a saga id for this saga and if we can't find it we shouldn't start a new one
return(false);
}
}
return(message.Metadata.MessageHierarchy.Any(messageType => sagaMetadata.IsMessageAllowedToStartTheSaga(messageType.FullName)));
}
IContainSagaData CreateNewSagaEntity(SagaMetadata metadata, LogicalMessage message)
{
var sagaEntityType = metadata.SagaEntityType;
var sagaEntity = (IContainSagaData)Activator.CreateInstance(sagaEntityType);
sagaEntity.Id = CombGuid.Generate();
sagaEntity.OriginalMessageId = message.Headers[Headers.MessageId];
string replyToAddress;
if (message.Headers.TryGetValue(Headers.ReplyToAddress, out replyToAddress))
{
sagaEntity.Originator = replyToAddress;
}
return(sagaEntity);
}
public void Should_not_blow_up()
{
var metadata = new MessageMetadata
{
TimeToBeReceived = TimeSpan.FromDays(1)
};
var message = new LogicalMessage(metadata, new MessageWithNullDataBusProperty(), new Dictionary <string, string>(), null);
var context = new SendLogicalMessageContext(null, new SendOptions(), message);
using (var stream = new MemoryStream())
{
new BinaryFormatter().Serialize(stream, "test");
stream.Position = 0;
sendBehavior.Invoke(context, () => { });
}
}
private static void CreateOutboundHeaders(IAgent agent, LogicalMessage logicalMessage)
{
if (logicalMessage.Headers == null)
{
return;
}
var setHeaders = new Action <LogicalMessage, string, string>((carrier, key, value) =>
{
if (carrier.Headers.ContainsKey(key))
{
carrier.Headers.Remove(key);
}
carrier.Headers.Add(key, value);
});
agent.CurrentTransaction.InsertDistributedTraceHeaders(logicalMessage, setHeaders);
}
public virtual async Task Invoke(LogicalMessage outgoingLogicalMessage, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration, TransportMessage incomingTransportMessage = null)
{
this.executingLogicalPipeline = new Queue <IOutgoingLogicalStep>(this.registeredlogicalPipelineSteps);
var logicalContext = new OutgoingLogicalContext(outgoingLogicalMessage, options, configuration);
logicalContext.SetChain(this);
await this.InvokeLogical(logicalContext)
.ConfigureAwait(false);
// We assume that someone in the pipeline made transport message
var outgoingTransportMessage = logicalContext.Get <TransportMessage>();
this.executingTransportPipeline = new Queue <IOutgoingTransportStep>(this.registeredTransportPipelineSteps);
var transportContext = new OutgoingTransportContext(outgoingLogicalMessage, outgoingTransportMessage, options, configuration, incomingTransportMessage);
transportContext.SetChain(this);
await this.InvokeTransport(transportContext)
.ConfigureAwait(false);
}
public void Invoke(SendLogicalMessageContext context, Action next)
{
#endregion
#region copy-stream-properties-to-disk
LogicalMessage logicalMessage = context.MessageToSend;
TimeSpan timeToBeReceived = logicalMessage.Metadata.TimeToBeReceived;
object message = logicalMessage.Instance;
foreach (PropertyInfo property in StreamStorageHelper.GetStreamProperties(message))
{
Stream sourceStream = (Stream)property.GetValue(message, null);
//Ignore null stream properties
if (sourceStream == null)
{
continue;
}
string fileKey = GenerateKey(timeToBeReceived);
string filePath = Path.Combine(location, fileKey);
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
using (FileStream target = File.OpenWrite(filePath))
{
sourceStream.CopyTo(target);
}
//Reset the property to null so no other serializer attempts to use the property
property.SetValue(message, null);
//Dispose of the stream
sourceStream.Dispose();
//Store the header so on the receiving endpoint the file name is known
string headerKey = StreamStorageHelper.GetHeaderKey(message, property);
logicalMessage.Headers["NServiceBus.PropertyStream." + headerKey] = fileKey;
}
next();
#endregion
}
/// <summary>
/// Keeps track of related messages to make auditing possible
/// </summary>
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
if (transportMessage.Headers.ContainsKey(Headers.ConversationId))
return;
var conversationId = CombGuid.Generate().ToString();
if (Bus.CurrentMessageContext != null)
{
transportMessage.Headers[Headers.RelatedTo] = Bus.CurrentMessageContext.Id;
string conversationIdFromCurrentMessageContext;
if (Bus.CurrentMessageContext.Headers.TryGetValue(Headers.ConversationId, out conversationIdFromCurrentMessageContext))
{
conversationId = conversationIdFromCurrentMessageContext;
}
}
transportMessage.Headers[Headers.ConversationId] = conversationId;
}
IContainSagaData TryLoadSagaEntity(ISaga saga, LogicalMessage message)
{
var sagaType = saga.GetType();
var sagaEntityType = Features.Sagas.GetSagaEntityTypeForSagaType(sagaType);
var finders = GetFindersFor(message.MessageType, sagaEntityType);
foreach (var finder in finders)
{
var sagaEntity = UseFinderToFindSaga(finder, message.Instance);
if (sagaEntity != null)
{
return(sagaEntity);
}
}
return(null);
}
public async Task Incoming_databus_properties_should_be_hydrated()
{
var propertyKey = Guid.NewGuid().ToString();
var databusKey = Guid.NewGuid().ToString();
var message = new LogicalMessage(new MessageMetadata(typeof(MessageWithDataBusProperty)), new MessageWithDataBusProperty
{
DataBusProperty = new DataBusProperty <string>("not used in this test")
{
Key = propertyKey
}
});
var fakeDatabus = new FakeDataBus();
var receiveBehavior = new DataBusReceiveBehavior(fakeDatabus, new XmlDataBusSerializer <string>(), new Conventions());
using (var stream = new MemoryStream())
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(string));
serializer.Serialize(stream, "test");
stream.Position = 0;
fakeDatabus.StreamsToReturn[databusKey] = stream;
await receiveBehavior.Invoke(
new IncomingLogicalMessageContext(
message,
"messageId",
"replyToAddress",
new Dictionary <string, string>
{
{ "NServiceBus.DataBus." + propertyKey, databusKey }
},
null),
ctx => Task.CompletedTask);
}
var instance = (MessageWithDataBusProperty)message.Instance;
Assert.AreEqual(instance.DataBusProperty.Value, "test");
}
TransportMessage GetTransportMessage(ToposMessage message)
{
var body = message.Body;
var headersOrNull = message.Headers;
var headers = headersOrNull?.Clone() ?? new Dictionary <string, string>();
if (!headers.ContainsKey(ToposHeaders.MessageId))
{
headers[ToposHeaders.MessageId] = Guid.NewGuid().ToString();
}
if (!headers.ContainsKey(ToposHeaders.Time))
{
headers[ToposHeaders.Time] = DateTimeOffset.Now.ToIso8601DateTimeOffset();
}
var logicalMessage = new LogicalMessage(headers, body);
var transportMessage = _messageSerializer.Serialize(logicalMessage);
return(transportMessage);
}
/// <summary>
/// Keeps track of related messages to make auditing possible
/// </summary>
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
if (transportMessage.Headers.ContainsKey(Headers.ConversationId))
{
return;
}
var conversationId = CombGuid.Generate().ToString();
if (Bus.CurrentMessageContext != null)
{
transportMessage.Headers[Headers.RelatedTo] = Bus.CurrentMessageContext.Id;
string conversationIdFromCurrentMessageContext;
if (Bus.CurrentMessageContext.Headers.TryGetValue(Headers.ConversationId, out conversationIdFromCurrentMessageContext))
{
conversationId = conversationIdFromCurrentMessageContext;
}
}
transportMessage.Headers[Headers.ConversationId] = conversationId;
}
public async Task Send(object message, string partitionKey = null, Dictionary <string, string> optionalHeaders = null)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var topic = _topicMapper.GetTopic(message);
var headers = optionalHeaders ?? new Dictionary <string, string>();
if (!headers.ContainsKey(ToposHeaders.MessageId))
{
headers[ToposHeaders.MessageId] = Guid.NewGuid().ToString();
}
var logicalMessage = new LogicalMessage(headers, message);
var transportMessage = _messageSerializer.Serialize(logicalMessage);
_logger.Debug("Sending message with ID {messageId} to topic {topic}", logicalMessage.GetMessageId(), topic);
await _producerImplementation.Send(topic, partitionKey ?? "", transportMessage);
}
IContainSagaData TryLoadSagaEntity(SagaMetadata metadata, LogicalMessage message)
{
string sagaId;
if (message.Headers.TryGetValue(Headers.SagaId, out sagaId) && !string.IsNullOrEmpty(sagaId))
{
var sagaEntityType = metadata.SagaEntityType;
//since we have a saga id available we can now shortcut the finders and just load the saga
var loaderType = typeof(LoadSagaByIdWrapper <>).MakeGenericType(sagaEntityType);
var loader = (SagaLoader)Activator.CreateInstance(loaderType);
return(loader.Load(SagaPersister, sagaId));
}
SagaFinderDefinition finderDefinition = null;
foreach (var messageType in message.Metadata.MessageHierarchy)
{
if (metadata.TryGetFinder(messageType.FullName, out finderDefinition))
{
break;
}
}
//check if we could find a finder
if (finderDefinition == null)
{
return(null);
}
var finderType = finderDefinition.Type;
var finder = currentContext.Builder.Build(finderType);
return(((SagaFinder)finder).Find(currentContext.Builder, finderDefinition, message));
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
// the outgoing message instance
var instance = logicalMessage.Instance;
// the bytes containing the serialized outgoing messages.
var bytes = transportMessage.Body;
// optionally replace the Body.
// this can be done using either the information from the logicalMessage or transportMessage
transportMessage.Body = ServiceThatChangesBody.Mutate(logicalMessage.Instance);
// the outgoing headers
var headers = transportMessage.Headers;
// optional manipulate headers
// add a header
headers.Add("MyHeaderKey1", "MyHeaderValue");
// remove a header
headers.Remove("MyHeaderKey2");
}
public IncomingLogicalContext(LogicalMessage message, Context parent) : base(parent)
{
Set(message);
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
transportMessage.Headers["Debug"] = Debug.ToString();
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
var headers = transportMessage.Headers;
headers.Add("MutateTransportMessages_Outgoing", "ValueMutateTransportMessages_Outgoing");
}
public MessageProcessingFailedException(string message, LogicalMessage incomingMessage, Exception innerException) : base(message, innerException)
{
this.message = message;
this.incomingMessage = incomingMessage;
this.innerException = innerException;
}
public ReceiveLogicalMessageContext(BehaviorContext parentContext, LogicalMessage message)
: base(parentContext)
{
Set(message);
}
private Task SendMessage(LogicalMessage outgoingLogicalMessage, DeliveryOptions options, TransportMessage incoming)
{
if (options.ReplyToAddress == null)
{
options.ReplyToAddress = this.configuration.EndpointQueue;
}
OutgoingPipeline outgoingPipeline = this.outgoingPipelineFactory.Create();
return outgoingPipeline.Invoke(outgoingLogicalMessage, options, this.readOnlyConfiguration, incoming);
}
public static string GetMessageId(this LogicalMessage message)
{
return(message.Headers.GetValue(ToposHeaders.MessageId));
}
IContainSagaData TryLoadSagaEntity(ISaga saga, LogicalMessage message)
{
var sagaType = saga.GetType();
var sagaEntityType = Features.Sagas.GetSagaEntityTypeForSagaType(sagaType);
var finders = GetFindersFor(message.MessageType, sagaEntityType);
foreach (var finder in finders)
{
var sagaEntity = UseFinderToFindSaga(finder, message.Instance);
if (sagaEntity != null)
return sagaEntity;
}
return null;
}
public OutgoingLogicalContext(LogicalMessage message, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
Set(message);
Set(options);
}
void Invoke(LogicalMessage message)
{
var context = new OutgoingContext(null, new SendOptions(Address.Parse("MyEndpoint")), message);
sendBehavior.Invoke(context, () => { });
}
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
transportMessage.Headers[Headers.WindowsIdentityName] = Thread.CurrentPrincipal.Identity.Name;
}
public TransportMessage Serialize(LogicalMessage message)
{
throw new NotImplementedException();
}
static bool IsTimeoutMessage(LogicalMessage message)
{
return(!string.IsNullOrEmpty(Headers.GetMessageHeader(message.Instance, Headers.IsSagaTimeoutMessage)));
}
public IncomingLogicalContext(LogicalMessage message, Context parent) : base(parent)
{
Set(message);
}
static bool IsTimeoutMessage(LogicalMessage message)
{
return !string.IsNullOrEmpty(Headers.GetMessageHeader(message.Instance, Headers.IsSagaTimeoutMessage));
}
internal IncomingLogicalMessageContext(LogicalMessage logicalMessage, IIncomingPhysicalMessageContext parentContext)
: this(logicalMessage, parentContext.MessageId, parentContext.ReplyToAddress, parentContext.Message.Headers, parentContext)
{
}
public SendLogicalMessageContext(BehaviorContext parentContext, SendOptions sendOptions, LogicalMessage message)
: base(parentContext)
{
Set(sendOptions);
Set(message);
}
public OutgoingLogicalContext(LogicalMessage message, DeliveryOptions options, EndpointConfiguration.ReadOnly configuration)
: base(configuration)
{
this.Set(message);
this.Set(options);
}
private static string GetMessageProperty(LogicalMessage message, string propertyName)
{
return(message.Instance.GetType().GetProperty(propertyName)?.GetValue(message.Instance, null)?.ToString());
}
public SendLogicalMessageContext(BehaviorContext parentContext, SendOptions sendOptions, LogicalMessage message)
: base(parentContext)
{
Set(sendOptions);
Set(message);
}
/// <summary>
/// Updates the message instance contained in <see cref="LogicalMessage" />.
/// </summary>
/// <param name="newInstance">The new instance.</param>
public virtual void UpdateMessageInstance(object newInstance)
{
Message = new LogicalMessage(new MessageMetadata(newInstance.GetType()), newInstance);
}
public TransportMessage Serialize(LogicalMessage message) => message.Body is byte[] bytes
public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
{
}
LogicalMessage[] Extract(IncomingMessage physicalMessage)
{
// We need this check to be compatible with v3.3 endpoints, v3.3 control messages also include a body
if (IsControlMessage(physicalMessage))
{
log.Debug("Received a control message. Skipping deserialization as control message data is contained in the header.");
return(NoMessagesFound);
}
if (physicalMessage.Body == null || physicalMessage.Body.Length == 0)
{
log.Debug("Received a message without body. Skipping deserialization.");
return(NoMessagesFound);
}
var messageMetadata = new List <MessageMetadata>();
if (physicalMessage.Headers.TryGetValue(Headers.EnclosedMessageTypes, out var messageTypeIdentifier))
{
foreach (var messageTypeString in messageTypeIdentifier.Split(EnclosedMessageTypeSeparator))
{
var typeString = messageTypeString;
if (DoesTypeHaveImplAddedByVersion3(typeString))
{
continue;
}
MessageMetadata metadata;
if (IsV4OrBelowScheduledTask(typeString))
{
metadata = messageMetadataRegistry.GetMessageMetadata(typeof(ScheduledTask));
}
else
{
metadata = messageMetadataRegistry.GetMessageMetadata(typeString);
}
if (metadata == null)
{
continue;
}
messageMetadata.Add(metadata);
}
if (messageMetadata.Count == 0 && physicalMessage.GetMessageIntent() != MessageIntentEnum.Publish)
{
log.WarnFormat("Could not determine message type from message header '{0}'. MessageId: {1}", messageTypeIdentifier, physicalMessage.MessageId);
}
}
var messageTypes = messageMetadata.Select(metadata => metadata.MessageType).ToList();
var messageSerializer = deserializerResolver.Resolve(physicalMessage.Headers);
mapper.Initialize(messageTypes);
// For nested behaviors who have an expectation ContentType existing
// add the default content type
physicalMessage.Headers[Headers.ContentType] = messageSerializer.ContentType;
using (var stream = new MemoryStream(physicalMessage.Body))
{
var deserializedMessages = messageSerializer.Deserialize(stream, messageTypes);
var logicalMessages = new LogicalMessage[deserializedMessages.Length];
for (var i = 0; i < deserializedMessages.Length; i++)
{
var x = deserializedMessages[i];
logicalMessages[i] = logicalMessageFactory.Create(x.GetType(), x);
}
return(logicalMessages);
}
}
/// <summary>
/// Creates a new instance of <see cref="OutgoingContext"/>.
/// </summary>
/// <param name="parentContext">The parent context.</param>
/// <param name="deliveryOptions">The delivery options.</param>
/// <param name="message">The actual message to be sent out.</param>
public OutgoingContext(BehaviorContext parentContext, DeliveryOptions deliveryOptions, LogicalMessage message)
: base(parentContext)
{
Set(deliveryOptions);
Set(OutgoingLogicalMessageKey, message);
}
public static bool IsControlMessage(this LogicalMessage transportMessage)
{
return(transportMessage.Headers != null &&
transportMessage.Headers.ContainsKey(Headers.ControlMessageHeader));
}
internal override IContainSagaData Find(IBuilder builder, SagaFinderDefinition finderDefinition, LogicalMessage message)
{
var customFinderType = (Type)finderDefinition.Properties["custom-finder-clr-type"];
var finder = (IFindSagas <TSagaData> .Using <TMessage>)builder.Build(customFinderType);
return(finder.FindBy((TMessage)message.Instance));
}
internal abstract IContainSagaData Find(IBuilder builder, SagaFinderDefinition finderDefinition, LogicalMessage message);
/// <summary>
/// Creates a <see cref="IIncomingLogicalMessageContext" /> based on the current context.
/// </summary>
public static IIncomingLogicalMessageContext CreateIncomingLogicalMessageContext(this StageConnector<IIncomingPhysicalMessageContext, IIncomingLogicalMessageContext> stageConnector, LogicalMessage logicalMessage, IIncomingPhysicalMessageContext sourceContext)
{
Guard.AgainstNull(nameof(logicalMessage), logicalMessage);
Guard.AgainstNull(nameof(sourceContext), sourceContext);
return new IncomingLogicalMessageContext(logicalMessage, sourceContext);
}
