public void TestAvoidHangAMQP_508()
{
var connectionFactory = new CachingConnectionFactory("localhost");
var longName = new string('x', 300);
var blockingQueueConsumer = new BlockingQueueConsumer(
connectionFactory,
new DefaultMessageHeadersConverter(),
new ActiveObjectCounter <BlockingQueueConsumer>(),
AcknowledgeMode.AUTO,
true,
1,
null,
longName,
"foobar");
try
{
blockingQueueConsumer.Start();
throw new Exception("Expected exception");
}
catch (FatalListenerStartupException e)
{
Assert.IsType <R.Exceptions.WireFormattingException>(e.InnerException);
}
finally
{
connectionFactory.Destroy();
}
}
public async Task TestDirect()
{
var cf = new CachingConnectionFactory("localhost");
var container = new DirectMessageListenerContainer(null, cf);
container.SetQueueNames(Q1, Q2);
container.ConsumersPerQueue = 2;
var listener = new ReplyingMessageListener();
var adapter = new MessageListenerAdapter(null, listener);
container.MessageListener = adapter;
container.ServiceName = "simple";
container.ConsumerTagStrategy = new TestConsumerTagStrategy(testName);
await container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
var template = new RabbitTemplate(cf);
Assert.Equal("FOO", template.ConvertSendAndReceive <string>(Q1, "foo"));
Assert.Equal("BAR", template.ConvertSendAndReceive <string>(Q2, "bar"));
await container.Stop();
Assert.True(await ConsumersOnQueue(Q1, 0));
Assert.True(await ConsumersOnQueue(Q2, 0));
Assert.True(await ActiveConsumerCount(container, 0));
Assert.Empty(container._consumersByQueue);
await template.Stop();
cf.Destroy();
}
public void TestAvoidHangAMQP_508()
{
var cf = new CachingConnectionFactory("localhost");
var admin = new RabbitAdmin(cf);
var bytes = new byte[300];
var longName = Encoding.UTF8.GetString(bytes).Replace('\u0000', 'x');
try
{
admin.DeclareQueue(new Queue(longName));
throw new Exception("expected exception");
}
catch (Exception)
{
// Ignore
}
var goodName = "foobar";
var name = admin.DeclareQueue(new Queue(goodName));
Assert.Null(admin.GetQueueProperties(longName));
Assert.NotNull(admin.GetQueueProperties(goodName));
admin.DeleteQueue(goodName);
cf.Destroy();
}
public void TestTransactionalLowLevel()
{
var connectionFactory = new CachingConnectionFactory("localhost");
var admin = new RabbitAdmin(connectionFactory);
admin.DeclareQueue(new Queue(QUEUE1_NAME));
admin.DeclareQueue(new Queue(QUEUE2_NAME));
var template = new RabbitTemplate(connectionFactory);
var blockingQueueConsumer = new BlockingQueueConsumer(
connectionFactory,
new DefaultMessageHeadersConverter(),
new ActiveObjectCounter <BlockingQueueConsumer>(),
AcknowledgeMode.AUTO,
true,
1,
null,
QUEUE1_NAME,
QUEUE2_NAME);
var prefix = Guid.NewGuid().ToString();
blockingQueueConsumer.TagStrategy = new TagStrategy(prefix);
try
{
blockingQueueConsumer.Start();
int n = 0;
var consumers = blockingQueueConsumer.CurrentConsumers();
// Wait for consumers
while (n < 100)
{
if (consumers.Count < 2)
{
n++;
Thread.Sleep(100);
consumers = blockingQueueConsumer.CurrentConsumers();
}
else
{
break;
}
}
Assert.Equal(2, consumers.Count);
var tags = new List <string>()
{
consumers[0].ConsumerTag, consumers[1].ConsumerTag
};
Assert.Contains(prefix + "#" + QUEUE1_NAME, tags);
Assert.Contains(prefix + "#" + QUEUE2_NAME, tags);
blockingQueueConsumer.Stop();
Assert.Null(template.ReceiveAndConvert <object>(QUEUE1_NAME));
}
finally
{
admin.DeleteQueue(QUEUE1_NAME);
admin.DeleteQueue(QUEUE2_NAME);
connectionFactory.Destroy();
}
}
public async Task TestMasterLocator()
{
var factory = new RC.ConnectionFactory
{
Uri = new Uri("amqp://*****:*****@localhost:5672/")
};
var cf = new CachingConnectionFactory(factory);
var admin = new RabbitAdmin(cf);
var queue = new AnonymousQueue();
admin.DeclareQueue(queue);
var client = new HttpClient();
var authToken = Encoding.ASCII.GetBytes("guest:guest");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authToken));
var result = await client.GetAsync("http://localhost:15672/api/queues/%3F/" + queue.QueueName);
var n = 0;
while (n++ < 100 && result.StatusCode == HttpStatusCode.NotFound)
{
await Task.Delay(100);
result = await client.GetAsync("http://localhost:15672/api/queues/%2F/" + queue.QueueName);
}
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
var content = await result.Content.ReadAsStringAsync();
Assert.Contains("x-queue-master-locator", content);
Assert.Contains("client-local", content);
queue = new AnonymousQueue
{
MasterLocator = null
};
admin.DeclareQueue(queue);
result = await client.GetAsync("http://localhost:15672/api/queues/%3F/" + queue.QueueName);
n = 0;
while (n++ < 100 && result.StatusCode == HttpStatusCode.NotFound)
{
await Task.Delay(100);
result = await client.GetAsync("http://localhost:15672/api/queues/%2F/" + queue.QueueName);
}
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
content = await result.Content.ReadAsStringAsync();
Assert.DoesNotContain("x-queue-master-locator", content);
Assert.DoesNotContain("client-local", content);
cf.Destroy();
}
public void TestUninterruptibleListenerDMLC()
{
var cf = new CachingConnectionFactory("localhost");
var admin = new RabbitAdmin(cf);
admin.DeclareQueue(new Config.Queue("test.shutdown"));
var container = new DirectMessageListenerContainer(null, cf)
{
ShutdownTimeout = 500
};
container.SetQueueNames("test.shutdown");
var latch = new CountdownEvent(1);
var testEnded = new CountdownEvent(1);
var listener = new TestListener(latch, testEnded);
container.MessageListener = listener;
var connection = cf.CreateConnection() as ChannelCachingConnectionProxy;
// var channels = TestUtils.getPropertyValue(connection, "target.delegate._channelManager._channelMap");
var field = typeof(RC.Framing.Impl.Connection)
.GetField("m_sessionManager", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.NotNull(field);
var channels = (SessionManager)field.GetValue(connection.Target.Connection);
Assert.NotNull(channels);
container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
try
{
var template = new RabbitTemplate(cf);
template.Execute(c =>
{
var properties = c.CreateBasicProperties();
var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
c.BasicPublish(string.Empty, "test.shutdown", false, properties, bytes);
RabbitUtils.SetPhysicalCloseRequired(c, false);
});
Assert.True(latch.Wait(TimeSpan.FromSeconds(30)));
Assert.Equal(2, channels.Count);
}
finally
{
container.Stop();
Assert.Equal(1, channels.Count);
cf.Destroy();
testEnded.Signal();
admin.DeleteQueue("test.shutdown");
}
}
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 TestNoDeclareWithCachedConnections()
{
var services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
services.AddLogging(b =>
{
b.AddDebug();
b.AddConsole();
});
services.AddSingleton <IConfiguration>(config);
services.AddRabbitHostingServices();
var mockConnectionFactory = new Mock <RC.IConnectionFactory>();
var mockConnections = new List <RC.IConnection>();
var mockChannels = new List <RC.IModel>();
var connectionNumber = new AtomicInteger(-1);
var channelNumber = new AtomicInteger(-1);
mockConnectionFactory.Setup(f => f.CreateConnection(It.IsAny <string>()))
.Callback(() =>
{
var connection = new Mock <RC.IConnection>();
var connectionNum = connectionNumber.IncrementAndGet();
mockConnections.Add(connection.Object);
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.ToString()).Returns("mockConnection" + connectionNum);
connection.Setup(c => c.CreateModel())
.Callback(() =>
{
var channel = new Mock <RC.IModel>();
mockChannels.Add(channel.Object);
channel.Setup(c => c.IsOpen).Returns(true);
var channelNum = channelNumber.IncrementAndGet();
channel.Setup(c => c.ToString()).Returns("mockChannel" + channelNum);
})
.Returns(() => mockChannels[channelNumber.Value]);
})
.Returns(() => mockConnections[connectionNumber.Value]);
var ccf = new CachingConnectionFactory(mockConnectionFactory.Object, false, CachingConnectionFactory.CachingMode.CONNECTION);
var queue = new Queue("foo");
services.AddRabbitQueue(queue);
var provider = services.BuildServiceProvider();
var context = provider.GetApplicationContext();
var admin = new RabbitAdmin(context, ccf);
ccf.CreateConnection().Close();
ccf.Destroy();
Assert.Empty(mockChannels);
}
public async Task TestReleaseConsumerRace()
{
var connectionFactory = new CachingConnectionFactory("localhost");
var container = new DirectReplyToMessageListenerContainer(null, connectionFactory);
var latch = new CountdownEvent(1);
container.MessageListener = new EmptyListener();
var mockMessageListener = new MockChannelAwareMessageListener(container.MessageListener, latch);
container.SetChannelAwareMessageListener(mockMessageListener);
var foobytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
var barbytes = EncodingUtils.GetDefaultEncoding().GetBytes("bar");
await container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
var channel1 = container.GetChannelHolder();
var props = channel1.Channel.CreateBasicProperties();
props.ReplyTo = Address.AMQ_RABBITMQ_REPLY_TO;
RC.IModelExensions.BasicPublish(channel1.Channel, string.Empty, TEST_RELEASE_CONSUMER_Q, props, foobytes);
var replyChannel = connectionFactory.CreateConnection().CreateChannel(false);
var request = replyChannel.BasicGet(TEST_RELEASE_CONSUMER_Q, true);
var n = 0;
while (n++ < 100 && request == null)
{
Thread.Sleep(100);
request = replyChannel.BasicGet(TEST_RELEASE_CONSUMER_Q, true);
}
Assert.NotNull(request);
props = channel1.Channel.CreateBasicProperties();
RC.IModelExensions.BasicPublish(replyChannel, string.Empty, request.BasicProperties.ReplyTo, props, barbytes);
replyChannel.Close();
Assert.True(latch.Wait(TimeSpan.FromSeconds(10)));
var channel2 = container.GetChannelHolder();
Assert.Same(channel1.Channel, channel2.Channel);
container.ReleaseConsumerFor(channel1, false, null); // simulate race for future timeout/cancel and onMessage()
var inUse = container._inUseConsumerChannels;
Assert.Single(inUse);
container.ReleaseConsumerFor(channel2, false, null);
Assert.Empty(inUse);
await container.Stop();
connectionFactory.Destroy();
}
public void TestAck()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var channel = new Mock <R.IModel>();
channel.Setup(c => c.IsOpen).Returns(true);
var props = new MockRabbitBasicProperties();
var getResponse = new R.BasicGetResult(123Ul, false, "ex", "rk", 0, props, Encoding.UTF8.GetBytes("foo"));
channel.Setup(c => c.BasicGet("foo", false)).Returns(getResponse);
var connection = new Mock <R.IConnection>();
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.CreateModel()).Returns(channel.Object);
var connectionFactory = new Mock <R.IConnectionFactory>();
connectionFactory.Setup(f => f.CreateConnection(It.IsAny <string>())).Returns(connection.Object);
var ccf = new CachingConnectionFactory(connectionFactory.Object);
var source = new RabbitMessageSource(context, ccf, "foo");
source.RawMessageHeader = true;
var received = source.Receive();
var rawMessage = received.Headers.Get <IMessage>(RabbitMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE);
var sourceData = received.Headers.Get <IMessage>(IntegrationMessageHeaderAccessor.SOURCE_DATA);
Assert.NotNull(rawMessage);
Assert.Same(rawMessage, sourceData);
Assert.Equal("foo", received.Headers.Get <string>(RabbitMessageHeaders.CONSUMER_QUEUE));
// make sure channel is not cached
var conn = ccf.CreateConnection();
var notCached = conn.CreateChannel(false);
connection.Verify(c => c.CreateModel(), Times.Exactly(2));
var callback = received.Headers.Get <IAcknowledgmentCallback>(IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK);
callback.Acknowledge(Status.ACCEPT);
channel.Verify(c => c.BasicAck(123ul, false));
var cached = conn.CreateChannel(false); // should have been "closed"
connection.Verify(c => c.CreateModel(), Times.Exactly(2));
notCached.Close();
cached.Close();
ccf.Destroy();
channel.Verify(c => c.Close(), Times.Exactly(2));
connection.Verify(c => c.Close(30000));
}
private void TestNackOrRequeue(bool requeue)
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var channel = new Mock <R.IModel>();
channel.Setup(c => c.IsOpen).Returns(true);
var props = new MockRabbitBasicProperties();
var getResponse = new R.BasicGetResult(123Ul, false, "ex", "rk", 0, props, Encoding.UTF8.GetBytes("bar"));
channel.Setup(c => c.BasicGet("foo", false)).Returns(getResponse);
var connection = new Mock <R.IConnection>();
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.CreateModel()).Returns(channel.Object);
var connectionFactory = new Mock <R.IConnectionFactory>();
connectionFactory.Setup(f => f.CreateConnection(It.IsAny <string>())).Returns(connection.Object);
var ccf = new CachingConnectionFactory(connectionFactory.Object);
var source = new RabbitMessageSource(context, ccf, "foo");
var received = source.Receive();
connection.Verify(c => c.CreateModel());
var callback = received.Headers.Get <IAcknowledgmentCallback>(IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK);
if (requeue)
{
callback.Acknowledge(Status.REQUEUE);
}
else
{
callback.Acknowledge(Status.REJECT);
}
channel.Verify(c => c.BasicReject(123ul, requeue));
connection.Verify(c => c.CreateModel());
ccf.Destroy();
channel.Verify(c => c.Close());
connection.Verify(c => c.Close(30000));
}
public void TestSendAndReceiveWithTopicConsumeInBackground()
{
provider = services.BuildServiceProvider();
var admin = provider.GetRabbitAdmin();
var exchange = new TopicExchange("topic");
admin.DeclareExchange(exchange);
var template = provider.GetRabbitTemplate();
template.DefaultSendDestination = new RabbitDestination(exchange.ExchangeName, string.Empty);
var binding = BindingBuilder.Bind(queue).To(exchange).With("*.end");
admin.DeclareBinding(binding);
var cachingConnectionFactory = new CachingConnectionFactory("localhost");
var template1 = new RabbitTemplate(cachingConnectionFactory)
{
DefaultSendDestination = new RabbitDestination(exchange.ExchangeName, string.Empty)
};
var consumer = template1.Execute(channel =>
{
var consumer1 = CreateConsumer(template1.ConnectionFactory);
var tag = consumer1.GetConsumerTags()[0];
Assert.NotNull(tag);
return(consumer1);
});
template1.ConvertAndSend("foo", "message");
var result = GetResult(consumer, false);
Assert.Null(result);
template1.ConvertAndSend("foo.end", "message");
result = GetResult(consumer, true);
Assert.Equal("message", result);
consumer.Stop();
admin.DeleteExchange("topic");
cachingConnectionFactory.Destroy();
}
public void Dispose()
{
connectionFactory.Destroy();
}
