How to use

AmqpRunnableFactory

in

com.nesscomputing.amqp

@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);