public void TestMissingContentType()
{
var bytes = Encoding.UTF8.GetBytes("{\"name\" : \"foo\" }");
var messageProperties = new MessageHeaders();
var message = Message.Create(bytes, messageProperties);
var j2Converter = new JsonMessageConverter();
var typeMapper = new DefaultTypeMapper
{
DefaultType = typeof(Foo)
};
j2Converter.TypeMapper = typeMapper;
var foo = j2Converter.FromMessage(message, null);
Assert.IsType <Foo>(foo);
var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties);
accessor.ContentType = null;
foo = j2Converter.FromMessage(message, null);
Assert.IsType <Foo>(foo);
j2Converter.AssumeSupportedContentType = false;
foo = j2Converter.FromMessage(message, null);
Assert.Same(foo, bytes);
}
public void TestSimpleBatchGZippedWithEncodingInflated()
{
var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000);
var template = new BatchingRabbitTemplate(batchingStrategy)
{
ConnectionFactory = connectionFactory
};
var gZipPostProcessor = new GZipPostProcessor();
template.SetBeforePublishPostProcessors(gZipPostProcessor);
template.SetAfterReceivePostProcessors(new DelegatingDecompressingPostProcessor());
var accessor = new RabbitHeaderAccessor(new MessageHeaders())
{
ContentEncoding = "foo"
};
var props = accessor.ToMessageHeaders();
var message = Message.Create(Encoding.UTF8.GetBytes("foo"), props);
template.Send(string.Empty, ROUTE, message);
message = Message.Create(Encoding.UTF8.GetBytes("bar"), props);
template.Send(string.Empty, ROUTE, message);
Thread.Sleep(100);
var output = template.ReceiveAndConvert <byte[]>(ROUTE);
Assert.NotNull(output);
Assert.Equal("\u0000\u0000\u0000\u0003foo\u0000\u0000\u0000\u0003bar", Encoding.UTF8.GetString(output));
}
public IMessage PostProcessMessage(IMessage message)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.Delay = 1000;
return(message);
}
public void TestReplyRetry()
{
adapter.DefaultListenerMethod = "Handle";
adapter.Instance = simpleService;
adapter.RetryTemplate = new PollyRetryTemplate(new Dictionary <Type, bool>(), 2, true, 1, 1, 1);
var replyMessage = new AtomicReference <IMessage>();
var replyAddress = new AtomicReference <Address>();
var throwable = new AtomicReference <Exception>();
adapter.RecoveryCallback = new TestRecoveryCallback(replyMessage, replyAddress, throwable);
var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties);
accessor.ReplyTo = "foo/bar";
var ex = new Exception();
var mockChannel = new Mock <IModel>();
mockChannel.Setup(c => c.BasicPublish("foo", "bar", false, It.IsAny <IBasicProperties>(), It.IsAny <byte[]>()))
.Throws(ex);
mockChannel.Setup(c => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties());
var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
var message = Message.Create(bytes, messageProperties);
adapter.OnMessage(message, mockChannel.Object);
Assert.Equal("Handle", simpleService.Called);
Assert.NotNull(replyMessage.Value);
var reply = EncodingUtils.GetDefaultEncoding().GetString((byte[])replyMessage.Value.Payload);
Assert.NotNull(replyAddress.Value);
var addr = replyAddress.Value;
Assert.Equal("foo", addr.ExchangeName);
Assert.Equal("bar", addr.RoutingKey);
Assert.Same(ex, throwable.Value);
}
public void TestMappedListenerMethod()
{
var map = new Dictionary <string, string>
{
{ "foo", "Handle" },
{ "bar", "NotDefinedOnInterface" }
};
adapter.DefaultListenerMethod = "AnotherHandle";
adapter.SetQueueOrTagToMethodName(map);
adapter.Instance = simpleService;
var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
var message = Message.Create(bytes, messageProperties);
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.ConsumerQueue = "foo";
accessor.ConsumerTag = "bar";
adapter.OnMessage(message, null);
Assert.Equal("Handle", simpleService.Called);
message = Message.Create(bytes, messageProperties);
accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.ConsumerQueue = "junk";
adapter.OnMessage(message, null);
Assert.Equal("NotDefinedOnInterface", simpleService.Called);
message = Message.Create(bytes, messageProperties);
accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.ConsumerTag = "junk";
adapter.OnMessage(message, null);
Assert.Equal("AnotherHandle", simpleService.Called);
}
public static IMessage <byte[]> CreateTextMessage(string body, MessageHeaders properties)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(properties);
accessor.ContentType = MimeTypeUtils.TEXT_PLAIN_VALUE;
return(Message.Create(ToBytes(body), properties));
}
private IMessage Handle(Delivery delivery)
{
if (delivery == null && Shutdown != null)
{
throw new ShutdownSignalException(Shutdown);
}
if (delivery == null)
{
return(null);
}
var body = delivery.Body;
var messageProperties = MessageHeadersConverter.ToMessageHeaders(delivery.Properties, delivery.Envelope, EncodingUtils.Utf8);
var accesor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties);
accesor.ConsumerTag = delivery.ConsumerTag;
accesor.ConsumerQueue = delivery.Queue;
var message = Message.Create(body, accesor.MessageHeaders);
Logger?.LogDebug("Received message: {message}", message);
if (messageProperties.DeliveryTag() != null)
{
DeliveryTags.Add(messageProperties.DeliveryTag().Value);
}
if (Transactional && !LocallyTransacted)
{
ConnectionFactoryUtils.RegisterDeliveryTag(ConnectionFactory, Channel, delivery.Envelope.DeliveryTag);
}
return(message);
}
public IMessage PostProcessMessage(IMessage message, CorrelationData correlation)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.Delay = 15000;
return(message);
}
private void TestFullConfiguration(IApplicationContext context)
{
var simpleFactory = context.GetService <IRabbitListenerContainerFactory>("simpleFactory") as RabbitListenerContainerTestFactory;
Assert.Single(simpleFactory.ListenerContainers);
var testContainer = simpleFactory.GetListenerContainers()[0];
var endpoint = testContainer.Endpoint as AbstractRabbitListenerEndpoint;
Assert.Equal("listener1", endpoint.Id);
AssertQueues(endpoint, "queue1", "queue2");
Assert.Empty(endpoint.Queues);
Assert.True(endpoint.Exclusive);
Assert.Equal(34, endpoint.Priority);
var admin = context.GetRabbitAdmin();
Assert.Same(endpoint.Admin, admin);
var container = new DirectMessageListenerContainer(context);
endpoint.SetupListenerContainer(container);
var listener = container.MessageListener as MessagingMessageListenerAdapter;
var accessor = new RabbitHeaderAccessor
{
ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN
};
var message = Message.Create(Encoding.UTF8.GetBytes("Hello"), accessor.MessageHeaders);
var mockChannel = new Mock <R.IModel>();
listener.OnMessage(message, mockChannel.Object);
}
protected virtual IMessage CreateMessage(IMessage message, byte[] compressed)
{
var headers = RabbitHeaderAccessor.GetMutableAccessor(message.Headers);
if (CopyHeaders)
{
headers = RabbitHeaderAccessor.GetMutableAccessor(new MessageHeaders(message.Headers, message.Headers.Id, message.Headers.Timestamp));
}
if (AutoDecompress)
{
headers.SetHeader(RabbitMessageHeaders.SPRING_AUTO_DECOMPRESS, true);
}
if (message.Headers.ContentEncoding() == null)
{
headers.ContentEncoding = GetEncoding();
}
else
{
headers.ContentEncoding = GetEncoding() + ":" + message.Headers.ContentEncoding();
}
return(Message.Create(compressed, headers.ToMessageHeaders()));
}
public void TestReplyToNullByDefault()
{
var properties = new RabbitHeaderAccessor();
Assert.Null(properties.ReplyTo);
Assert.Null(properties.ReplyToAddress);
}
public void TestSimpleBatchDeflaterWithEncoding()
{
var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000);
var template = new BatchingRabbitTemplate(batchingStrategy)
{
ConnectionFactory = connectionFactory
};
var deflatorPostProcessor = new DeflaterPostProcessor
{
Level = CompressionLevel.Fastest
};
template.SetBeforePublishPostProcessors(deflatorPostProcessor);
var accessor = new RabbitHeaderAccessor(new MessageHeaders())
{
ContentEncoding = "foo"
};
var props = accessor.ToMessageHeaders();
var message = Message.Create(Encoding.UTF8.GetBytes("foo"), props);
template.Send(string.Empty, ROUTE, message);
message = Message.Create(Encoding.UTF8.GetBytes("bar"), props);
template.Send(string.Empty, ROUTE, message);
var result = Receive(template);
Assert.Equal("deflate:foo", result.Headers.ContentEncoding());
var unzipper = new InflaterPostProcessor();
var unzip = unzipper.PostProcessMessage(result);
Assert.Equal("\u0000\u0000\u0000\u0003foo\u0000\u0000\u0000\u0003bar", Encoding.UTF8.GetString((byte[])unzip.Payload));
}
private IMessage <byte[]> AssembleMessage()
{
if (_messages.Count == 1)
{
return(_messages[0]);
}
var accessor = RabbitHeaderAccessor.GetMutableAccessor(_messages[0]);
var body = new byte[_currentSize];
var bytes = new Span <byte>(body);
var index = 0;
foreach (var message in _messages)
{
var slice = bytes.Slice(index);
BinaryPrimitives.WriteInt32BigEndian(slice, message.Payload.Length);
index += 4;
slice = bytes.Slice(index);
for (var i = 0; i < message.Payload.Length; i++)
{
slice[i] = message.Payload[i];
}
index = index + message.Payload.Length;
}
accessor.SetHeader(RabbitMessageHeaders.SPRING_BATCH_FORMAT, RabbitMessageHeaders.BATCH_FORMAT_LENGTH_HEADER4);
accessor.SetHeader(RabbitMessageHeaders.BATCH_SIZE, _messages.Count);
return(Message.Create(body, accessor.MessageHeaders));
}
public IMessage PostProcessMessage(IMessage message)
{
var headers = RabbitHeaderAccessor.GetMutableAccessor(message);
headers.SetHeader("someHeader", "someValue");
return(message);
}
public virtual bool HandleError(Exception exception)
{
_logger?.LogWarning(exception, "Execution of Rabbit message listener failed.");
if (!CauseChainContainsRRADRE(exception) && _exceptionStrategy.IsFatal(exception))
{
if (DiscardFatalsWithXDeath && exception is ListenerExecutionFailedException listenerException)
{
var failed = listenerException.FailedMessage;
if (failed != null)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(failed);
var xDeath = accessor.GetXDeathHeader();
if (xDeath != null && xDeath.Count > 0)
{
_logger?.LogError(
"x-death header detected on a message with a fatal exception; "
+ "perhaps requeued from a DLQ? - discarding: {failedMessage} ", failed);
throw new ImmediateAcknowledgeException("Fatal and x-death present");
}
}
}
throw new RabbitRejectAndDontRequeueException("Error Handler converted exception to fatal", RejectManual, exception);
}
return(true);
}
public IMessage PostProcessMessage(IMessage message)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.RemoveHeaders("__TypeId__");
return(message);
}
protected virtual void AddDelayProperty(IMessage message)
{
if (DelayGenerator != null)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.Delay = DelayGenerator.ProcessMessage(message);
}
}
public void TestReplyTo()
{
var properties = new RabbitHeaderAccessor
{
ReplyTo = "foo/bar"
};
Assert.Equal("bar", properties.ReplyToAddress.RoutingKey);
}
public void ShouldThrowAnExceptionWhenContentClassIdIsNotPresentWhenClassIdIsContainerType()
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(List <>).FullName);
var excep = Assert.Throws <MessageConversionException>(() => typeMapper.ToType(accessor.MessageHeaders));
Assert.Contains("Could not resolve ", excep.Message);
}
public void TestContentLengthSet()
{
var properties = new RabbitHeaderAccessor
{
ContentLength = 1L
};
Assert.True(properties.IsContentLengthSet);
}
public void ProperEncoding()
{
var message = Message.Create(EncodingUtils.Utf16.GetBytes("ÁRVÍZTŰRŐ TÜKÖRFÚRÓGÉP"), new MessageHeaders());
var acccessor = RabbitHeaderAccessor.GetMutableAccessor(message);
acccessor.ContentType = MessageHeaders.CONTENT_TYPE_JSON;
acccessor.ContentEncoding = "UTF-16";
Assert.Contains("ÁRVÍZTŰRŐ TÜKÖRFÚRÓGÉP", message.ToString());
}
public void TestAdapterConversionError()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var channel = new Mock <RC.IModel>();
channel.Setup(c => c.IsOpen).Returns(true);
var connection = new Mock <Messaging.RabbitMQ.Connection.IConnection>();
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>();
connectionFactory.Setup(f => f.CreateConnection()).Returns(connection.Object);
var container = new DirectMessageListenerContainer();
container.ConnectionFactory = connectionFactory.Object;
var adapter = new RabbitInboundChannelAdapter(context, container);
var outputChannel = new QueueChannel(context);
adapter.OutputChannel = outputChannel;
var errorChannel = new QueueChannel(context);
adapter.ErrorChannel = errorChannel;
adapter.MessageConverter = new ThrowingMessageConverter();
var accessor = new RabbitHeaderAccessor();
accessor.DeliveryTag = 123ul;
var headers = accessor.MessageHeaders;
var message = Message.Create(string.Empty, headers);
var listener = container.MessageListener as IChannelAwareMessageListener;
listener.OnMessage(message, null);
Assert.Null(outputChannel.Receive(0));
var received = errorChannel.Receive(0);
Assert.NotNull(received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE));
Assert.IsType <ListenerExecutionFailedException>(received.Payload);
container.AcknowledgeMode = Messaging.RabbitMQ.Core.AcknowledgeMode.MANUAL;
var channel2 = new Mock <RC.IModel>();
listener.OnMessage(message, channel2.Object);
Assert.Null(outputChannel.Receive(0));
received = errorChannel.Receive(0);
Assert.NotNull(received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE));
Assert.IsType <ManualAckListenerExecutionFailedException>(received.Payload);
var ex = (ManualAckListenerExecutionFailedException)received.Payload;
Assert.Same(channel2.Object, ex.Channel);
Assert.Equal(123ul, ex.DeliveryTag);
}
public IMessage PostProcessMessage(IMessage message)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.ContentType = "text/other";
accessor.SetHeader("strings", new string[] { "1", "2" });
accessor.SetHeader("objects", new object[] { new Foo(), new Foo() });
accessor.SetHeader("bytes", EncodingUtils.Utf8.GetBytes("abc"));
return(message);
}
public IMessage PostProcessMessage(IMessage message)
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.ContentType = "application/json";
accessor.UserId = "guest";
accessor.SetHeader("stringHeader", "string");
accessor.SetHeader("intHeader", 42);
return(message);
}
public void ChannelReleasedOnTimeout()
{
var connectionFactory = new CachingConnectionFactory("localhost");
var rabbitTemplate = CreateSendAndReceiveRabbitTemplate(connectionFactory);
rabbitTemplate.ReplyTimeout = 1;
var exception = new AtomicReference <Exception>();
var latch = new CountdownEvent(1);
rabbitTemplate.ReplyErrorHandler = new TestErrorHandler(exception, latch);
var reply = rabbitTemplate.ConvertSendAndReceive <object>(ROUTE, "foo");
Assert.Null(reply);
var directReplyToContainers = rabbitTemplate._directReplyToContainers;
var container = rabbitTemplate.UsePublisherConnection ? directReplyToContainers[connectionFactory.PublisherConnectionFactory] : directReplyToContainers[connectionFactory];
Assert.Empty(container._inUseConsumerChannels);
Assert.Same(rabbitTemplate.ReplyErrorHandler, container.ErrorHandler);
var replyMessage = Message.Create(Encoding.UTF8.GetBytes("foo"), new MessageHeaders());
var ex = Assert.Throws <RabbitRejectAndDontRequeueException>(() => rabbitTemplate.OnMessage(replyMessage));
Assert.Contains("No correlation header in reply", ex.Message);
var accessor = RabbitHeaderAccessor.GetMutableAccessor(replyMessage);
accessor.CorrelationId = "foo";
ex = Assert.Throws <RabbitRejectAndDontRequeueException>(() => rabbitTemplate.OnMessage(replyMessage));
Assert.Contains("Reply received after timeout", ex.Message);
_ = Task.Run(() =>
{
var message = rabbitTemplate.Receive(ROUTE, 10000);
Assert.NotNull(message);
rabbitTemplate.Send(message.Headers.ReplyTo(), replyMessage);
return(message);
});
while (rabbitTemplate.Receive(ROUTE, 100) != null)
{
}
reply = rabbitTemplate.ConvertSendAndReceive <object>(ROUTE, "foo");
Assert.Null(reply);
Assert.True(latch.Wait(TimeSpan.FromSeconds(10)));
Assert.IsType <ListenerExecutionFailedException>(exception.Value);
var listException = exception.Value as ListenerExecutionFailedException;
Assert.Contains("Reply received after timeout", exception.Value.InnerException.Message);
Assert.Equal(replyMessage.Payload, listException.FailedMessage.Payload);
Assert.Empty(container._inUseConsumerChannels);
rabbitTemplate.Stop().Wait();
connectionFactory.Destroy();
}
public void ShouldLookInTheContentClassIdFieldNameToFindTheContainerClassIDWhenClassIdIsContainerType()
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader("contentType", typeof(string).ToString());
accessor.SetHeader(typeMapper.ClassIdFieldName, typeof(List <>).FullName);
typeMapper.ContentClassIdFieldName = "contentType";
var type = typeMapper.ToType(accessor.MessageHeaders);
Assert.Equal(typeof(List <string>), type);
}
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 void ShouldLookInTheClassIdFieldNameToFindTheClassName()
{
var accessor = RabbitHeaderAccessor.GetMutableAccessor(headers);
accessor.SetHeader("type", "System.String");
typeMapper.ClassIdFieldName = "type";
var type = typeMapper.ToType(accessor.MessageHeaders);
Assert.Equal(typeof(string), type);
}
public void MessageToString()
{
var converter = new SimpleMessageConverter();
var message = Message.Create(Encoding.UTF8.GetBytes("test"), new MessageHeaders());
var accessor = RabbitHeaderAccessor.GetMutableAccessor(message);
accessor.ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN;
var result = converter.FromMessage <string>(message);
Assert.Equal("test", result);
}
protected override object DoReceive()
{
var connection = ConnectionFactory.CreateConnection();
var channel = connection.CreateChannel(Transacted);
try
{
var resp = channel.BasicGet(QueueName, false);
if (resp == null)
{
RabbitUtils.CloseChannel(channel);
RabbitUtils.CloseConnection(connection);
return(null);
}
var callback = AckCallbackFactory.CreateCallback(new RabbitAckInfo(connection, channel, Transacted, resp));
var envelope = new Envelope(resp.DeliveryTag, resp.Redelivered, resp.Exchange, resp.RoutingKey);
var messageProperties = MessageHeaderConverter.ToMessageHeaders(resp.BasicProperties, envelope, EncodingUtils.Utf8);
var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties);
accessor.ConsumerQueue = this.QueueName;
// Map<String, Object> headers = this.headerMapper.toHeadersFromRequest(messageProperties);
var message = Message.Create <byte[]>(resp.Body, accessor.MessageHeaders);
object payload;
if (BatchingStrategy.CanDebatch(message.Headers))
{
var payloads = new List <object>();
BatchingStrategy.DeBatch(message, fragment => payloads.Add(MessageConverter.FromMessage(fragment, null)));
payload = payloads;
}
else
{
payload = MessageConverter.FromMessage(message, null);
}
var builder = MessageBuilderFactory.WithPayload(payload)
.CopyHeaders(accessor.MessageHeaders)
.SetHeader(IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK, callback);
if (RawMessageHeader)
{
builder.SetHeader(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE, message);
builder.SetHeader(IntegrationMessageHeaderAccessor.SOURCE_DATA, message);
}
return(builder);
}
catch (Exception e)
{
RabbitUtils.CloseChannel(channel);
RabbitUtils.CloseConnection(connection);
throw RabbitExceptionTranslator.ConvertRabbitAccessException(e);
}
}
