@Override protected void configure() { final Named connectionNamed; final AmqpConfig amqpConfig; connectionNamed = Names.named(connectionName); bind(new TypeLiteral<PublisherCallback<Object>>() {}).annotatedWith(JsonMapper.class).to(JsonPublisherCallback.class).in(Scopes.SINGLETON); bind(new TypeLiteral<PublisherCallback<String>>() {}).to(StringPublisherCallback.class).in(Scopes.SINGLETON); amqpConfig = config.getBean(AmqpConfig.class, ImmutableMap.of("name", connectionName)); bind(AmqpConfig.class).annotatedWith(connectionNamed).toInstance(amqpConfig); if (amqpConfig.isEnabled()) { LOG.info("Enabling AMQP for '%s'", connectionName); bind(ConnectionFactory.class).annotatedWith(connectionNamed).toProvider(new AmqpFactoryProvider(amqpConfig)).in(Scopes.SINGLETON); bind(AmqpRunnableFactory.class).annotatedWith(connectionNamed).toInstance(new AmqpRunnableFactory(connectionNamed)); } else { LOG.info("Disabled AMQP for '%s'", connectionName); } }
@Test public void testSimpleProducer() throws Exception { final ExchangePublisher<Object> exchangeConsumer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); Assert.assertNotNull(exchangeConsumer); }
@Test public void stopConsumerWithNoMessages() throws Exception { final ExchangeConsumer exchangeConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", new DummyMessageCallback()); Assert.assertNotNull(exchangeConsumer); final Thread topicThread = new Thread(exchangeConsumer); topicThread.start(); Thread.sleep(2000L); Assert.assertTrue(exchangeConsumer.isConnected()); exchangeConsumer.shutdown(); topicThread.interrupt(); topicThread.join(); }
final ExchangeConsumer exchangeConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", callback); final ExchangePublisher<Object> exchangeProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final Thread consumerThread = new Thread(exchangeConsumer); final Thread producerThread = new Thread(exchangeProducer);
@Test public void testProduceConsume() throws Exception { final CountingMessageCallback cmc = new CountingMessageCallback(); final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", cmc); final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue"); final Thread consumerThread = new Thread(queueConsumer); final Thread producerThread = new Thread(queuePublisher); consumerThread.start(); producerThread.start(); Thread.sleep(1000L); Assert.assertTrue(queueConsumer.isConnected()); Assert.assertFalse(queuePublisher.isConnected()); final int maxCount = 1000; for (int i = 0; i < maxCount; i++) { queuePublisher.put(format("hello, world %d", i)); } Thread.sleep(DRAIN_SLEEP); Assert.assertTrue(queuePublisher.isEmpty()); Assert.assertEquals(maxCount, cmc.getCount()); queuePublisher.shutdown(); queueConsumer.shutdown(); producerThread.interrupt(); consumerThread.interrupt(); producerThread.join(); consumerThread.join(); }
@Test public void testSimpleProducer() throws Exception { final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue"); Assert.assertNotNull(queuePublisher); }
@Test public void stopConsumerWithNoMessages() throws Exception { final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", new DummyMessageCallback()); Assert.assertNotNull(queueConsumer); final Thread queueThread = new Thread(queueConsumer); queueThread.start(); Thread.sleep(2000L); Assert.assertTrue(queueConsumer.isConnected()); queueConsumer.shutdown(); queueThread.interrupt(); queueThread.join(); }
@Test public void testProduceConsume() throws Exception { final CountingMessageCallback cmc = new CountingMessageCallback(); final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", cmc); final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final Thread consumerThread = new Thread(topicConsumer); final Thread producerThread = new Thread(topicProducer); consumerThread.start(); producerThread.start(); Thread.sleep(1000L); Assert.assertTrue(topicConsumer.isConnected()); Assert.assertFalse(topicProducer.isConnected()); final int maxCount = 1000; for (int i = 0; i < maxCount; i++) { topicProducer.put(format("hello, world %d", i)); } Thread.sleep(DRAIN_SLEEP); Assert.assertTrue(topicProducer.isEmpty()); Assert.assertEquals(maxCount, cmc.getCount()); topicProducer.shutdown(); topicConsumer.shutdown(); producerThread.interrupt(); consumerThread.interrupt(); producerThread.join(); consumerThread.join(); }
final QueueConsumer queueConsumer1 = queueRunnableFactory.createQueueListener("test-queue", cmc1); final QueueConsumer queueConsumer2 = queueRunnableFactory.createQueueListener("test-queue", cmc2); final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue"); final Thread consumerThread1 = new Thread(queueConsumer1); final Thread consumerThread2 = new Thread(queueConsumer2);
@Test public void stopProducerWithNoMessages() throws Exception { final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue"); Assert.assertNotNull(queuePublisher); final Thread queueThread = new Thread(queuePublisher); queueThread.start(); Thread.sleep(2000L); Assert.assertFalse(queuePublisher.isConnected()); queuePublisher.shutdown(); queueThread.interrupt(); queueThread.join(); }
@Test public void testSimpleConsumer() throws Exception { final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", new DummyMessageCallback()); Assert.assertNotNull(queueConsumer); }
final ExchangeConsumer topicConsumer1 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc1); final ExchangeConsumer topicConsumer2 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc2); final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final Thread consumerThread1 = new Thread(topicConsumer1); final Thread consumerThread2 = new Thread(topicConsumer2);
final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", cmc); final QueuePublisher<Object> queuePublisher1 = queueRunnableFactory.createQueueJsonPublisher("test-queue"); final QueuePublisher<Object> queuePublisher2 = queueRunnableFactory.createQueueJsonPublisher("test-queue"); final Thread consumerThread = new Thread(queueConsumer); final Thread producerThread1 = new Thread(queuePublisher1);
@Test public void stopProducerWithNoMessages() throws Exception { final ExchangePublisher<Object>topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); Assert.assertNotNull(topicProducer); final Thread topicThread = new Thread(topicProducer); topicThread.start(); Thread.sleep(2000L); Assert.assertFalse(topicProducer.isConnected()); topicProducer.shutdown(); topicThread.interrupt(); topicThread.join(); }
@Test public void testSimpleConsumer() throws Exception { final ExchangeConsumer exchangeConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", new DummyMessageCallback()); Assert.assertNotNull(exchangeConsumer); }
final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", cmc); final ExchangePublisher<Object> topicProducer1 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final ExchangePublisher<Object> topicProducer2 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final Thread consumerThread = new Thread(topicConsumer); final Thread producerThread1 = new Thread(topicProducer1);
final QueueConsumer queueConsumer1 = queueRunnableFactory.createQueueListener("test-queue", cmc1); final QueueConsumer queueConsumer2 = queueRunnableFactory.createQueueListener("test-queue", cmc2); final QueuePublisher<Object> queuePublisher1 = queueRunnableFactory.createQueueJsonPublisher("test-queue"); final QueuePublisher<Object> queuePublisher2 = queueRunnableFactory.createQueueJsonPublisher("test-queue"); final Thread consumerThread1 = new Thread(queueConsumer1); final Thread consumerThread2 = new Thread(queueConsumer2);
final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", callback); final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final Thread consumerThread = new Thread(topicConsumer); final Thread producerThread = new Thread(topicProducer);
final ExchangeConsumer topicConsumer1 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc1); final ExchangeConsumer topicConsumer2 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc2); final ExchangePublisher<Object> topicProducer1 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final ExchangePublisher<Object> topicProducer2 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final Thread consumerThread1 = new Thread(topicConsumer1); final Thread consumerThread2 = new Thread(topicConsumer2);
final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", callback); final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic"); final Thread consumerThread = new Thread(topicConsumer); final Thread producerThread = new Thread(topicProducer);