container.setBeanName("replyContainer"); container.setQueueNames("asyncRQ1"); container.afterPropertiesSet(); container.start(); AsyncRabbitTemplate asyncTemplate = new AsyncRabbitTemplate(template, container); }); receiver.setMessageListener(messageListener); receiver.afterPropertiesSet(); receiver.start();
private SimpleMessageListenerContainer createContainer(MessageListener listener) { SimpleMessageListenerContainer container = createContainer(listener, queue.getName()); container.afterPropertiesSet(); container.start(); return container; }
@SuppressWarnings("unchecked") @Test public void testConsumerArgs() throws Exception { ConnectionFactory connectionFactory = mock(ConnectionFactory.class); Connection connection = mock(Connection.class); Channel channel = mock(Channel.class); when(connectionFactory.createConnection()).thenReturn(connection); when(connection.createChannel(false)).thenReturn(channel); final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>(); final AtomicReference<Map<?, ?>> args = new AtomicReference<Map<?, ?>>(); doAnswer(invocation -> { consumer.set(invocation.getArgument(6)); consumer.get().handleConsumeOk("foo"); args.set(invocation.getArgument(5)); return "foo"; }).when(channel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(), any(Map.class), any(Consumer.class)); final SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory); container.setQueueNames("foo"); container.setMessageListener((MessageListener) message -> { }); container.setConsumerArguments(Collections.<String, Object>singletonMap("x-priority", Integer.valueOf(10))); container.afterPropertiesSet(); container.start(); verify(channel).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(), any(Map.class), any(Consumer.class)); assertTrue(args.get() != null); assertEquals(10, args.get().get("x-priority")); consumer.get().handleCancelOk("foo"); container.stop(); }
@Test public void testAddQueuesAndStartInCycle() throws Exception { ConnectionFactory connectionFactory = mock(ConnectionFactory.class); Connection connection = mock(Connection.class); Channel channel1 = mock(Channel.class); when(channel1.isOpen()).thenReturn(true); when(connectionFactory.createConnection()).thenReturn(connection); when(connection.createChannel(false)).thenReturn(channel1); final AtomicInteger count = new AtomicInteger(); doAnswer(invocation -> { Consumer cons = invocation.getArgument(6); String consumerTag = "consFoo" + count.incrementAndGet(); cons.handleConsumeOk(consumerTag); return consumerTag; }).when(channel1).basicConsume(anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(), anyMap(), any(Consumer.class)); final SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory); container.setMessageListener((MessageListener) message -> { }); container.afterPropertiesSet(); for (int i = 0; i < 10; i++) { container.addQueueNames("foo" + i); if (!container.isRunning()) { container.start(); } } container.stop(); }
@Test public void testContainerNotRecoveredAfterExhaustingRecoveryBackOff() throws Exception { SimpleMessageListenerContainer container = spy(new SimpleMessageListenerContainer(mock(ConnectionFactory.class))); container.setQueueNames("foo"); container.setRecoveryBackOff(new FixedBackOff(100, 3)); container.setConcurrentConsumers(3); doAnswer(invocation -> { BlockingQueueConsumer consumer = spy((BlockingQueueConsumer) invocation.callRealMethod()); doThrow(RuntimeException.class).when(consumer).start(); return consumer; }).when(container).createBlockingQueueConsumer(); container.afterPropertiesSet(); container.start(); // Since backOff exhausting makes listenerContainer as invalid (calls stop()), // it is enough to check the listenerContainer activity int n = 0; while (container.isActive() && n++ < 100) { Thread.sleep(100); } assertThat(n, lessThanOrEqualTo(100)); }
@Test public void testManualAckWithClosedChannel() throws Exception { final AtomicReference<IllegalStateException> exc = new AtomicReference<>(); final CountDownLatch latch = new CountDownLatch(1); this.container = createContainer((ChannelAwareMessageListener) (m, c) -> { if (exc.get() == null) { ((CachingConnectionFactory) this.template.getConnectionFactory()).resetConnection(); } try { c.basicAck(m.getMessageProperties().getDeliveryTag(), false); } catch (IllegalStateException e) { exc.set(e); } latch.countDown(); }, false, this.queue.getName()); this.container.setAcknowledgeMode(AcknowledgeMode.MANUAL); this.container.afterPropertiesSet(); this.container.start(); this.template.convertAndSend(this.queue.getName(), "foo"); assertTrue(latch.await(10, TimeUnit.SECONDS)); this.container.stop(); assertNotNull(exc.get()); assertThat(exc.get().getMessage(), equalTo("Channel closed; cannot ack/nack")); }
}); container.setReceiveTimeout(100); container.afterPropertiesSet(); container.start(); try {
private SimpleMessageListenerContainer createContainer(MessageListener listener, boolean start, String... queueNames) { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(template.getConnectionFactory()); if (listener != null) { container.setMessageListener(listener); } if (queueNames != null) { container.setQueueNames(queueNames); } container.setReceiveTimeout(50); container.afterPropertiesSet(); if (start) { container.start(); } return container; }
@Test public void testIncreaseMinAtMax() throws Exception { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(this.connectionFactory); container.setStartConsumerMinInterval(100); container.setConsecutiveActiveTrigger(1); container.setMessageListener(m -> { try { Thread.sleep(50); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); container.setQueueNames(QUEUE2); container.setConcurrentConsumers(2); container.setMaxConcurrentConsumers(5); container.afterPropertiesSet(); container.start(); RabbitTemplate template = new RabbitTemplate(this.connectionFactory); for (int i = 0; i < 20; i++) { template.convertAndSend(QUEUE2, "foo"); } waitForNConsumers(container, 5); container.setConcurrentConsumers(4); Set<?> consumers = (Set<?>) TestUtils.getPropertyValue(container, "consumers"); assertThat(consumers.size(), equalTo(5)); }
@Test public void testDecreaseMinAtMax() throws Exception { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(this.connectionFactory); container.setStartConsumerMinInterval(100); container.setConsecutiveActiveTrigger(1); container.setMessageListener(m -> { try { Thread.sleep(50); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); container.setQueueNames(QUEUE3); container.setConcurrentConsumers(2); container.setMaxConcurrentConsumers(3); container.afterPropertiesSet(); container.start(); RabbitTemplate template = new RabbitTemplate(this.connectionFactory); for (int i = 0; i < 20; i++) { template.convertAndSend(QUEUE3, "foo"); } waitForNConsumers(container, 3); container.setConcurrentConsumers(1); Set<?> consumers = (Set<?>) TestUtils.getPropertyValue(container, "consumers"); assertThat(consumers.size(), equalTo(3)); }
private SimpleMessageListenerContainer createContainer(String queueName, Object listener, ConnectionFactory connectionFactory) { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory); container.setMessageListener(new MessageListenerAdapter(listener)); container.setQueueNames(queueName); container.setTxSize(txSize); container.setPrefetchCount(txSize); container.setConcurrentConsumers(concurrentConsumers); container.setChannelTransacted(transactional); container.setAcknowledgeMode(acknowledgeMode); container.setTaskExecutor(Executors.newFixedThreadPool(concurrentConsumers)); container.afterPropertiesSet(); container.start(); return container; }
@Test public void testDefaultConsumerCount() throws Exception { final SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory("localhost"); SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(singleConnectionFactory); container.setMessageListener(new MessageListenerAdapter(this)); container.setQueueNames("foo"); container.setAutoStartup(false); container.afterPropertiesSet(); assertEquals(1, ReflectionTestUtils.getField(container, "concurrentConsumers")); container.stop(); singleConnectionFactory.destroy(); }
@Test public void testInconsistentAcknowledgeConfiguration() throws Exception { final SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory("localhost"); SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(singleConnectionFactory); container.setMessageListener(new MessageListenerAdapter(this)); container.setQueueNames("foo"); container.setChannelTransacted(true); container.setAcknowledgeMode(AcknowledgeMode.NONE); expectedException.expect(IllegalStateException.class); container.afterPropertiesSet(); container.stop(); singleConnectionFactory.destroy(); }
private SimpleMessageListenerContainer createContainer(Object listener) { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(template.getConnectionFactory()); container.setMessageListener(new MessageListenerAdapter(listener)); container.setQueueNames(queue.getName()); container.setTxSize(txSize); container.setPrefetchCount(txSize); container.setConcurrentConsumers(concurrentConsumers); container.setChannelTransacted(transactional); container.setAcknowledgeMode(AcknowledgeMode.MANUAL); container.afterPropertiesSet(); container.start(); return container; }
private SimpleMessageListenerContainer createContainer(Object listener) { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(template.getConnectionFactory()); container.setMessageListener(new MessageListenerAdapter(listener)); container.setQueueNames(queue.getName()); container.setTxSize(txSize); container.setPrefetchCount(txSize); container.setConcurrentConsumers(concurrentConsumers); container.setChannelTransacted(transactional); container.setAcknowledgeMode(AcknowledgeMode.AUTO); container.afterPropertiesSet(); container.start(); return container; }
@Test public void testChannelTransactedOverriddenWhenTxManager() throws Exception { final SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory("localhost"); SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(singleConnectionFactory); container.setMessageListener(new MessageListenerAdapter(this)); container.setQueueNames("foo"); container.setChannelTransacted(false); container.setTransactionManager(new TestTransactionManager()); container.afterPropertiesSet(); assertTrue(TestUtils.getPropertyValue(container, "transactional", Boolean.class)); container.stop(); singleConnectionFactory.destroy(); }
@Test public void testMPPsAppliedReplyContainerTests() { this.template.setReplyAddress(REPLIES); SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(this.config.cf()); try { container.setQueueNames(REPLIES); container.setMessageListener(this.template); container.setAfterReceivePostProcessors(this.config.afterMPP()); container.afterPropertiesSet(); container.start(); this.template.sendAndReceive(new Message("foo".getBytes(), new MessageProperties())); assertTrue("before MPP not called", this.config.beforeMppCalled); assertTrue("after MPP not called", this.config.afterMppCalled); } finally { container.stop(); } }
@Test public void testInconsistentTransactionConfiguration() throws Exception { final SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory("localhost"); SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(singleConnectionFactory); container.setMessageListener(new MessageListenerAdapter(this)); container.setQueueNames("foo"); container.setChannelTransacted(false); container.setAcknowledgeMode(AcknowledgeMode.NONE); container.setTransactionManager(new TestTransactionManager()); expectedException.expect(IllegalStateException.class); container.afterPropertiesSet(); container.stop(); singleConnectionFactory.destroy(); }
protected SimpleMessageListenerContainer doCreateContainer(String queueName, Object listener, ConnectionFactory connectionFactory, ApplicationContext context) { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory); container.setMessageListener(new MessageListenerAdapter(listener)); container.setQueueNames(queueName); container.setPrefetchCount(1); container.setConcurrentConsumers(concurrentConsumers); container.setChannelTransacted(transactional); container.setAcknowledgeMode(acknowledgeMode); container.setRecoveryInterval(100); container.setFailedDeclarationRetryInterval(100); container.setReceiveTimeout(50); if (context != null) { container.setApplicationContext(context); } container.afterPropertiesSet(); return container; }
@Test public void testAddQueuesAndStartInCycle() throws Exception { final SimpleMessageListenerContainer container = new SimpleMessageListenerContainer( this.connectionFactory); container.setMessageListener((MessageListener) message -> { }); container.setConcurrentConsumers(2); container.afterPropertiesSet(); RabbitAdmin admin = new RabbitAdmin(this.connectionFactory); for (int i = 0; i < 20; i++) { Queue queue = new Queue("testAddQueuesAndStartInCycle" + i); admin.declareQueue(queue); container.addQueueNames(queue.getName()); if (!container.isRunning()) { container.start(); } } int n = 0; while (n++ < 100 && container.getActiveConsumerCount() != 2) { Thread.sleep(100); } assertEquals(2, container.getActiveConsumerCount()); container.stop(); for (int i = 0; i < 20; i++) { admin.deleteQueue("testAddQueuesAndStartInCycle" + i); } connectionFactory.destroy(); }