/// <summary>
/// Writes message headers to the underlying stream or writer
/// </summary>
/// <param name="headers">The message headers</param>
/// <returns>Returns a task that completes when the message headers have been
/// written to the underlying stream or writer</returns>
public async Task WriteMessageHeaders(IMessageHeaders headers)
{
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
foreach (var header in headers)
{
var headerName = header.Key;
var headerValue = header.Value;
await _writer.WriteAsync($"{headerName}: ");
using (var headerValueReader = new StringReader(headerValue))
{
var multilineContinuation = false;
string line;
while ((line = await headerValueReader.ReadLineAsync()) != null)
{
if (multilineContinuation)
{
// Prefix continuation with whitespace so that subsequent
// lines are not confused with different headers.
line = " " + line;
}
await _writer.WriteLineAsync(line);
multilineContinuation = true;
}
}
}
// Blank line to denote end of headers
await _writer.WriteLineAsync();
}
/// <summary>
/// Creates a new <see cref="Message"/> by serializing the specified <paramref name="content"/>
/// and appending the negotiated <see cref="IMessageHeaders.MessageName"/> and
/// <see cref="IMessageHeaders.ContentType"/> to the resulting <see cref="Message.Headers"/>
/// </summary>
/// <param name="content">The message content</param>
/// <param name="headers">The initial headers for the message</param>
/// <returns>A message consisting of the serialized <see cref="content"/> and the
/// supplied <paramref name="headers"/> augmented with the <see cref="IMessageHeaders.MessageName"/>
/// and <see cref="IMessageHeaders.ContentType"/> used to serialize the content</returns>
public Message Marshal(object content, IMessageHeaders headers)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
if (headers == null)
{
throw new ArgumentNullException(nameof(headers));
}
var messageName = _messageNamingService.GetNameForType(content.GetType());
var contentType = headers.ContentType;
if (string.IsNullOrWhiteSpace(headers.ContentType))
{
contentType = _defaultContentType;
}
var newHeaders = new MessageHeaders(headers)
{
MessageName = messageName,
ContentType = contentType
};
var serializer = _serializationService.GetSerializer(contentType);
var serializedContent = serializer.Serialize(content);
return(new Message(newHeaders, serializedContent));
}
/// <summary>
/// Sets a header value as UTF8 string
/// </summary>
/// <param name="headers">The <see cref="IMessageHeaders"/> object that this method was called on.</param>
/// <param name="key">The header key</param>
/// <param name="value">The header value</param>
public static void SetString(
this IMessageHeaders headers,
string key,
string value)
{
headers.SetString(key, value, Encoding.UTF8);
}
/// <summary>
/// A helper method to serialize message headers so that they can be inserted into a
/// single column in the SQL database
/// </summary>
/// <param name="headers">The message headers to serialize</param>
/// <returns>Returns the serialized message headers</returns>
protected virtual string SerializeHeaders(IMessageHeaders headers)
{
if (headers == null)
{
return(null);
}
using (var writer = new StringWriter())
{
foreach (var header in headers)
{
var headerName = header.Key;
var headerValue = header.Value;
writer.Write("{0}: ", headerName);
using (var headerValueReader = new StringReader(headerValue))
{
var multilineContinuation = false;
string line;
while ((line = headerValueReader.ReadLine()) != null)
{
if (multilineContinuation)
{
// Prefix continuation with whitespace so that subsequent
// lines are not confused with different headers.
line = " " + line;
}
writer.WriteLine(line);
multilineContinuation = true;
}
}
}
return(writer.ToString());
}
}
public void AssertHeadersAreEqual(IMessageHeaders actual, IMessageHeaders expected)
{
Assert.That(actual.Id, Is.EqualTo(expected.Id));
Assert.That(actual.ReplyTo, Is.EqualTo(expected.ReplyTo));
Assert.That(actual.Priority, Is.EqualTo(expected.Priority));
Assert.That(actual.RetryAttempts, Is.EqualTo(expected.RetryAttempts));
}
public MimeType Resolve(IMessageHeaders headers)
{
if (headers == null || !headers.ContainsKey(MessageHeaders.CONTENT_TYPE))
{
return(DefaultMimeType);
}
var value = headers[MessageHeaders.CONTENT_TYPE];
if (value == null)
{
return(null);
}
else if (value is MimeType mimeType)
{
return(mimeType);
}
else if (value is string stringVal)
{
return(MimeType.ToMimeType(stringVal));
}
else
{
throw new ArgumentException("Unknown type for contentType header value: " + value.GetType());
}
}
protected virtual IMessage CreateOutputMessage(object output, IMessageHeaders requestHeaders)
{
IMessageBuilder builder;
if (output is IMessage outputAsMessage)
{
if (_noHeadersPropagation || !ShouldCopyRequestHeaders)
{
return(outputAsMessage);
}
builder = IntegrationServices.MessageBuilderFactory.FromMessage((IMessage)output);
}
else
{
builder = IntegrationServices.MessageBuilderFactory.WithPayload(output);
}
if (!_noHeadersPropagation && ShouldCopyRequestHeaders)
{
builder.FilterAndCopyHeadersIfAbsent(requestHeaders, _selectiveHeaderPropagation ? _notPropagatedHeaders.ToArray() : null);
}
return(builder.Build());
}
public void Produce(
string topic,
string partitionKey,
object message,
IMessageHeaders headers = null,
Action <XXXDeliveryReport> deliveryHandler = null)
{
var messageKey = partitionKey is null ? null : Encoding.UTF8.GetBytes(partitionKey);
this.middlewareExecutor.Execute(new ProducerMessageContext(message, messageKey, headers, topic),
context =>
{
var completionSource = new TaskCompletionSource <byte>();
this.InternalProduce((ProducerMessageContext)context,
report =>
{
if (report.Error.IsError)
{
//completionSource.SetException(new ProduceException<byte[], byte[]>(report.Error, report));
completionSource.SetException(new Exception(report.Error.ToString()));
}
else
{
completionSource.SetResult(0);
}
deliveryHandler?.Invoke(report);
});
return(completionSource.Task);
});
}
protected override object ConvertToInternal(object payload, IMessageHeaders headers, object conversionHint)
{
var serializer = JsonSerializer.Create(Settings);
try
{
if (typeof(byte[]) == SerializedPayloadClass)
{
var memStream = new MemoryStream(1024);
var encoding = GetJsonEncoding(GetMimeType(headers));
var writer = new StreamWriter(memStream, encoding)
{
AutoFlush = true
};
serializer.Serialize(writer, payload);
payload = memStream.ToArray();
}
else
{
var writer = new StringWriter();
serializer.Serialize(writer, payload);
payload = writer.ToString();
}
}
catch (Exception ex)
{
throw new MessageConversionException("Could not write JSON: " + ex.Message, ex);
}
return(payload);
}
public async Task <DeliveryResult <byte[], byte[]> > ProduceAsync(
string topic,
string partitionKey,
object message,
IMessageHeaders headers = null)
{
var messageKey = partitionKey is null ? null : Encoding.UTF8.GetBytes(partitionKey);
DeliveryResult <byte[], byte[]> report = null;
await this.middlewareExecutor
.Execute(
new ProducerMessageContext(
message,
messageKey,
headers,
topic),
async context =>
{
report = await this
.InternalProduceAsync((ProducerMessageContext)context)
.ConfigureAwait(false);
})
.ConfigureAwait(false);
return(report);
}
public Task <XXXDeliveryResult> ProduceAsync(
string partitionKey,
object message,
IMessageHeaders headers = null)
{
return(this.producer.ProduceAsync(partitionKey, message, headers));
}
private Message BuildMessage(object content, IMessageHeaders suppliedHeaders, SendOptions options)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
var headers = new MessageHeaders(suppliedHeaders)
{
MessageId = MessageId.Generate(),
Origination = _baseUri,
Synchronous = options != null && options.Synchronous
};
if (options != null && options.TTL > TimeSpan.Zero)
{
headers.Expires = DateTime.UtcNow.Add(options.TTL);
}
var contentType = options?.ContentType;
if (string.IsNullOrWhiteSpace(contentType))
{
contentType = _defaultContentType;
}
headers.ContentType = contentType;
return(_messageMarshaller.Marshal(content, headers));
}
public BusMessageContext(Bus bus, IMessageHeaders headers, IPrincipal senderPrincipal)
{
if (bus == null) throw new ArgumentNullException("bus");
if (headers == null) throw new ArgumentNullException("headers");
_bus = bus;
_headers = headers;
_senderPrincipal = senderPrincipal;
}
/// <summary>
/// Sets a header value as string
/// </summary>
/// <param name="headers"></param>
/// <param name="key">The header key</param>
/// <param name="value">The header value</param>
/// <param name="encoding">The encoding used to store the string</param>
public static void SetString(
this IMessageHeaders headers,
string key,
string value,
Encoding encoding)
{
headers[key] = encoding.GetBytes(value);
}
public void Produce(
string partitionKey,
object message,
IMessageHeaders headers = null,
Action <XXXDeliveryReport> deliveryHandler = null)
{
this.producer.Produce(partitionKey, message, headers, deliveryHandler);
}
public Type GetInferredType(IMessageHeaders headers)
{
if (HasInferredTypeHeader(headers) && Precedence.Equals(TypePrecedence.INFERRED))
{
return(FromInferredTypeHeader(headers));
}
return(null);
}
protected override bool CanConvertTo(object payload, IMessageHeaders headers = null)
{
if (!SupportsMimeType(headers))
{
return(false);
}
return(true);
}
public bool CanDebatch(IMessageHeaders properties)
{
if (properties.TryGetValue(RabbitMessageHeaders.SPRING_BATCH_FORMAT, out var value))
{
return((value as string) == RabbitMessageHeaders.BATCH_FORMAT_LENGTH_HEADER4);
}
return(false);
}
protected override Task HandleInternal(EpisodeNumberUpdated domainEvent, IMessageHeaders headers, CancellationToken cancellationToken = default(CancellationToken))
{
if (domainEvent.Barcode == ExpectedBarcode)
{
EventReceived = true;
manualResetEventSlim.Set();
}
return(Task.CompletedTask);
}
public Task <DeliveryResult <byte[], byte[]> > ProduceAsync(
object partitionKey,
object message,
IMessageHeaders headers = null)
{
return(this.producer.ProduceAsync(
partitionKey,
message,
headers));
}
public MessageContext(
Message message,
IMessageHeaders headers,
IConsumerContext consumer,
IProducerContext producer)
{
this.Message = message;
this.Headers = headers ?? new MessageHeaders();
this.ConsumerContext = consumer;
this.ProducerContext = producer;
}
public static bool IsDeliveryTagSet(this IMessageHeaders headers)
{
var result = DeliveryTag(headers);
if (result.HasValue)
{
return(true);
}
return(false);
}
public static bool IsContentLengthSet(this IMessageHeaders headers)
{
var len = ContentLength(headers);
if (len.HasValue)
{
return(true);
}
return(false);
}
public static bool IsFinalRetryForMessageWithNoId(this IMessageHeaders headers)
{
var result = FinalRetryForMessageWithNoId(headers);
if (result.HasValue)
{
return(result.Value);
}
return(false);
}
public static Address ReplyToAddress(this IMessageHeaders headers)
{
var results = headers.ReplyTo();
if (results != null)
{
return(new Address(results));
}
return(null);
}
/// <summary>
/// Creates a batch produce item
/// </summary>
/// <param name="topic"></param>
/// <param name="partitionKey"></param>
/// <param name="message"></param>
/// <param name="headers"></param>
public BatchProduceItem(
string topic,
string partitionKey,
object message,
IMessageHeaders headers)
{
this.Topic = topic;
this.PartitionKey = partitionKey;
this.Message = message;
this.Headers = headers;
}
private static async Task <byte[]> MarshalHeaders(IMessageHeaders headers)
{
using (var stream = new MemoryStream())
{
using (var messageWriter = new MessageWriter(stream, Encoding.UTF8, true))
{
await messageWriter.WriteMessageHeaders(headers);
}
return(stream.ToArray());
}
}
protected override object ConvertToInternal(object payload, IMessageHeaders headers, object conversionHint)
{
if (typeof(byte[]) == SerializedPayloadClass)
{
var charset = GetContentTypeCharset(GetMimeType(headers));
var payStr = (string)payload;
payload = charset.GetBytes(payStr);
}
return(payload);
}
protected new RabbitHeaderAccessor CreateMutableAccessor(IMessageHeaders messageHeaders)
{
var headers = messageHeaders as MessageHeaders;
if (headers == null)
{
throw new InvalidOperationException("Unable to create mutable accessor, message has no headers or headers are not of type MessageHeaders");
}
return(new RabbitHeaderAccessor(headers));
}
protected override IMessage CreateMessage(object payload, IMessageHeaders messageProperties, object conversionHint)
{
byte[] bytes = null;
var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties);
if (payload is byte[])
{
bytes = (byte[])payload;
accessor.ContentType = MessageHeaders.CONTENT_TYPE_BYTES;
}
else if (payload is string)
{
try
{
var enc = EncodingUtils.GetEncoding(DefaultCharset);
bytes = enc.GetBytes((string)payload);
}
catch (Exception e)
{
throw new MessageConversionException("failed to convert to Message content", e);
}
accessor.ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN;
accessor.ContentEncoding = DefaultCharset;
}
else if (payload.GetType().IsSerializable)
{
try
{
var formatter = new BinaryFormatter();
var stream = new MemoryStream(512);
// TODO: don't disable this warning! https://aka.ms/binaryformatter
#pragma warning disable SYSLIB0011 // Type or member is obsolete
formatter.Serialize(stream, payload);
#pragma warning restore SYSLIB0011 // Type or member is obsolete
bytes = stream.ToArray();
accessor.ContentType = MessageHeaders.CONTENT_TYPE_DOTNET_SERIALIZED_OBJECT;
}
catch (Exception e)
{
throw new MessageConversionException("failed to convert serialized Message content", e);
}
}
if (bytes == null)
{
throw new ArgumentException("SimpleMessageConverter only supports string, byte[] and serializable payloads, received: " + payload?.GetType().Name);
}
var message = Message.Create(bytes, messageProperties);
accessor.ContentLength = bytes.Length;
return(message);
}
public Task <DeliveryResult <byte[], byte[]> > ProduceAsync(
string partitionKey,
object message,
IMessageHeaders headers = null)
{
return(this.ProduceAsync(
this.configuration.Topic,
partitionKey,
message,
headers));
}
private Message BuildMessage(object content, IMessageHeaders suppliedHeaders = null,
SendOptions options = default(SendOptions))
{
if (content == null) throw new ArgumentNullException("content");
var messageName = _messageNamingService.GetNameForType(content.GetType());
var headers = new MessageHeaders(suppliedHeaders)
{
MessageId = MessageId.Generate(),
MessageName = messageName,
Origination = _baseUri,
Importance = options.Importance
};
var contentType = options.ContentType;
if (string.IsNullOrWhiteSpace(contentType))
{
contentType = "application/json";
}
headers.ContentType = contentType;
var serializer = _serializationService.GetSerializer(headers.ContentType);
var serializedContent = serializer.Serialize(content);
return new Message(headers, serializedContent);
}
public Message(IMessageHeaders headers, string content)
{
if (headers == null) throw new ArgumentNullException("headers");
_headers = headers;
_content = content ?? "";
}
protected virtual string SerializeHeaders(IMessageHeaders headers)
{
if (headers == null) return null;
using (var writer = new StringWriter())
{
foreach (var header in headers)
{
var headerName = header.Key;
var headerValue = header.Value;
writer.Write("{0}: ", headerName);
using (var headerValueReader = new StringReader(headerValue))
{
var multilineContinuation = false;
string line;
while ((line = headerValueReader.ReadLine()) != null)
{
if (multilineContinuation)
{
// Prefix continuation with whitespace so that subsequent
// lines are not confused with different headers.
line = " " + line;
}
writer.WriteLine(line);
multilineContinuation = true;
}
}
}
return writer.ToString();
}
}
public RabbitMQQueuedMessageContext(IMessageHeaders headers, IPrincipal senderPrincipal)
{
_headers = headers;
_senderPrincipal = senderPrincipal;
}
