public Message(TransportMessage message)
{
ReceivingEndpoint = EndpointDetails.ReceivingEndpoint(message);
Id = message.Id + "-" + ReceivingEndpoint.Name;
MessageId = message.Id;
CorrelationId = message.CorrelationId;
Recoverable = message.Recoverable;
MessageIntent = message.MessageIntent;
Headers = message.Headers.Select(header => new KeyValuePair <string, string>(header.Key, header.Value));
TimeSent = DateTimeExtensions.ToUtcDateTime(message.Headers[NServiceBus.Headers.TimeSent]);
if (message.IsControlMessage())
{
MessageType = "SystemMessage";
IsSystemMessage = true;
}
else
{
var messageTypeString = message.Headers[NServiceBus.Headers.EnclosedMessageTypes];
MessageType = GetMessageType(messageTypeString);
IsSystemMessage = DetectSystemMessage(messageTypeString);
ContentType = DetermineContentType(message);
Body = DeserializeBody(message, ContentType);
BodyRaw = message.Body;
RelatedToMessageId = message.Headers.ContainsKey(NServiceBus.Headers.RelatedTo) ? message.Headers[NServiceBus.Headers.RelatedTo] : null;
ConversationId = message.Headers[NServiceBus.Headers.ConversationId];
OriginatingSaga = SagaDetails.Parse(message);
IsDeferredMessage = message.Headers.ContainsKey(NServiceBus.Headers.IsDeferredMessage);
}
OriginatingEndpoint = EndpointDetails.OriginatingEndpoint(message);
}
/// <summary>
/// Ensure that the content type which is introduced in V4.0.0 and later versions is present in the header.
/// </summary>
/// <param name="transportMessage">Transport Message to mutate.</param>
public void MutateIncoming(TransportMessage transportMessage)
{
if (!transportMessage.IsControlMessage() && !transportMessage.Headers.ContainsKey(Headers.ContentType))
{
transportMessage.Headers[Headers.ContentType] = Serializer.ContentType;
}
}
public Message(TransportMessage message)
{
ReceivingEndpoint = EndpointDetails.ReceivingEndpoint(message);
Id = message.Id + "-" + ReceivingEndpoint.Name;
MessageId = message.Id;
CorrelationId = message.CorrelationId;
Recoverable = message.Recoverable;
MessageIntent = message.MessageIntent;
Headers = message.Headers.Select(header => new KeyValuePair<string, string>(header.Key, header.Value));
TimeSent = DateTimeExtensions.ToUtcDateTime(message.Headers[NServiceBus.Headers.TimeSent]);
if (message.IsControlMessage())
{
MessageType = "SystemMessage";
IsSystemMessage = true;
}
else
{
var messageTypeString = message.Headers[NServiceBus.Headers.EnclosedMessageTypes];
MessageType = GetMessageType(messageTypeString);
IsSystemMessage = DetectSystemMessage(messageTypeString);
ContentType = DetermineContentType(message);
Body = DeserializeBody(message, ContentType);
BodyRaw = message.Body;
RelatedToMessageId = message.Headers.ContainsKey(NServiceBus.Headers.RelatedTo) ? message.Headers[NServiceBus.Headers.RelatedTo] : null;
ConversationId = message.Headers[NServiceBus.Headers.ConversationId];
OriginatingSaga = SagaDetails.Parse(message);
IsDeferredMessage = message.Headers.ContainsKey(NServiceBus.Headers.IsDeferredMessage);
}
OriginatingEndpoint = EndpointDetails.OriginatingEndpoint(message);
}
public void Invoke(OutgoingContext context, Action next)
{
TransportMessage transportMessage = context.OutgoingMessage;
if (!transportMessage.IsControlMessage())
{
LogicalMessage logicalMessage = context.OutgoingLogicalMessage;
object messageInstance = logicalMessage.Instance;
Type messageType = messageInstance.GetType();
IMessageSerializer messageSerializer = serializationMapper.GetSerializer(messageType);
transportMessage.Body = Serialize(messageSerializer, messageInstance);
Dictionary <string, string> transportHeaders = transportMessage.Headers;
transportHeaders[Headers.ContentType] = messageSerializer.ContentType;
transportHeaders[Headers.EnclosedMessageTypes] = SerializeEnclosedMessageTypes(logicalMessage);
foreach (KeyValuePair <string, string> headerEntry in logicalMessage.Headers)
{
transportHeaders[headerEntry.Key] = headerEntry.Value;
}
}
next();
}
/// <summary>
/// Ensure that the content type which is introduced in V4.0.0 and later versions is present in the header.
/// </summary>
/// <param name="transportMessage">Transport Message to mutate.</param>
public void MutateIncoming(TransportMessage transportMessage)
{
if (!transportMessage.IsControlMessage() && !transportMessage.Headers.ContainsKey(Headers.ContentType))
{
transportMessage.Headers[Headers.ContentType] = Serializer.ContentType;
}
}
private static EventData ToEventData(TransportMessage transportMessage, EventStoreMessageMetadata metadata)
{
metadata.CorrelationId = transportMessage.CorrelationId;
metadata.MessageId = transportMessage.Id;
metadata.ReplyTo = transportMessage.ReplyToAddress.ToString();
metadata.Headers = transportMessage.Headers;
var type = transportMessage.IsControlMessage()
? "ControlMessage"
: transportMessage.Headers[Headers.EnclosedMessageTypes];
byte[] data;
string contentType;
if (transportMessage.Headers.TryGetValue(Headers.ContentType, out contentType))
{
if (contentType != ContentTypes.Json)
{
throw new InvalidOperationException("Invalid content type: " + contentType);
}
data = transportMessage.Body;
}
else
{
data = new byte[0];
}
return(new EventData(Guid.NewGuid(), type, true, data, metadata.ToJsonBytes()));
}
bool HandleCorrelatedMessage(TransportMessage transportMessage, LogicalMessages messages)
{
if (transportMessage.CorrelationId == null)
{
return false;
}
if (transportMessage.CorrelationId == transportMessage.Id) //to make sure that we don't fire callbacks when doing send locals
{
return false;
}
BusAsyncResult busAsyncResult;
if (!UnicastBus.messageIdToAsyncResultLookup.TryRemove(transportMessage.CorrelationId, out busAsyncResult))
{
return false;
}
var statusCode = int.MinValue;
if (transportMessage.IsControlMessage())
{
string errorCode;
if (transportMessage.Headers.TryGetValue(Headers.ReturnMessageErrorCodeHeader, out errorCode))
{
statusCode = int.Parse(errorCode);
}
}
busAsyncResult.Complete(statusCode, messages.Select(lm=>lm.Instance).ToArray());
return true;
}
/// <summary>
/// This method is called when a message is available to be processed.
/// </summary>
/// <param name="message">
/// The <see cref="TransportMessage" /> received.
/// </param>
public bool Handle(TransportMessage message)
{
if (!message.IsControlMessage())
return true;
HandleControlMessage(message);
return true;
}
/// <summary>
/// This method is called when a message is available to be processed.
/// </summary>
/// <param name="message">
/// The <see cref="TransportMessage" /> received.
/// </param>
public bool Handle(TransportMessage message)
{
if (!message.IsControlMessage())
{
return(true);
}
HandleControlMessage(message);
return(true);
}
public IMessage Encode(TransportMessage message, ISession session)
{
if (message.IsControlMessage())
{
IMessage encoded = session.CreateBytesMessage();
if (message.Body != null)
{
encoded = session.CreateBytesMessage(message.Body);
}
return(encoded);
}
return(null);
}
public IMessage Encode(TransportMessage message, ISession session)
{
if (message.IsControlMessage())
{
IMessage encoded = session.CreateBytesMessage();
if (message.Body != null)
{
encoded = session.CreateBytesMessage(message.Body);
}
return encoded;
}
return null;
}
/// <summary>
/// This method is called when a message is available to be processed.
/// </summary>
/// <param name="message">
/// The <see cref="TransportMessage" /> received.
/// </param>
public bool Handle(TransportMessage message)
{
if (!message.IsControlMessage())
{
return(true);
}
if (message.Headers.ContainsKey(Headers.UnregisterWorker))
{
HandleDisconnectMessage(message);
return(true);
}
HandleControlMessage(message);
return(true);
}
/// <summary>
/// This method is called when a message is available to be processed.
/// </summary>
/// <param name="message">
/// The <see cref="TransportMessage" /> received.
/// </param>
public bool Handle(TransportMessage message)
{
if (!message.IsControlMessage())
{
return true;
}
if (message.Headers.ContainsKey(Headers.UnregisterWorker))
{
HandleDisconnectMessage(message);
return true;
}
HandleControlMessage(message);
return true;
}
/// <summary>
/// Allow for a V3.X subscriber to subscribe/unsubscribe to a V2.6 publisher
/// Mutate outgoing subscribe/unsubscribe messages: Create and serialize a completion message into the
/// body of the transport message.
/// </summary>
/// <param name="messages"></param>
/// <param name="transportMessage"></param>
public void MutateOutgoing(object[] messages, TransportMessage transportMessage)
{
if ((transportMessage.IsControlMessage() &&
((transportMessage.MessageIntent == MessageIntentEnum.Subscribe) ||
(transportMessage.MessageIntent == MessageIntentEnum.Unsubscribe) ||
(transportMessage.MessageIntent == MessageIntentEnum.Send))))
{
var stream = new MemoryStream();
var completionMessage = new CompletionMessage();
if (transportMessage.Headers.ContainsKey(Headers.ReturnMessageErrorCodeHeader))
{
completionMessage.ErrorCode = int.Parse(transportMessage.Headers[Headers.ReturnMessageErrorCodeHeader]);
}
MessageSerializer.Serialize(new object[] { completionMessage }, stream);
transportMessage.Body = stream.ToArray();
Log.Debug("Added Completion message and sending message intent: " + transportMessage.MessageIntent);
}
}
public void Invoke(IncomingContext context, Action next)
{
TransportMessage transportMessage = context.PhysicalMessage;
if (transportMessage.IsControlMessage())
{
logger.Info("Received a control message. Skipping deserialization as control message data is contained in the header.");
next();
return;
}
try
{
context.LogicalMessages = Extract(transportMessage);
}
catch (Exception exception)
{
throw new MessageDeserializationException(transportMessage.Id, exception);
}
next();
}
