Example usage for org.springframework.amqp.rabbit.core RabbitAdmin deleteQueue

List of usage examples for org.springframework.amqp.rabbit.core RabbitAdmin deleteQueue

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.amqp.rabbit.core.*
  5. RabbitAdmin
  6. deleteQueue

Introduction

In this page you can find the example usage for org.springframework.amqp.rabbit.core RabbitAdmin deleteQueue.

Prototype

@Override
    @ManagedOperation(description = "Delete a queue from the broker")
    public boolean deleteQueue(final String queueName)

Source Link

Usage

From source file:multibinder.RabbitAndKafkaBinderApplicationTests.java

@After
public void cleanUp() {
    RabbitAdmin admin = new RabbitAdmin(rabbitTestSupport.getResource());
    admin.deleteQueue("binder.dataOut.default");
    admin.deleteQueue("binder.dataOut." + this.randomGroup);
    admin.deleteExchange("binder.dataOut");
}

From source file:com.noriental.solr.config.test.BrokerRunning.java

public void removeTestQueues() {
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setHost("localhost");
    RabbitAdmin admin = new RabbitAdmin(connectionFactory);
    for (Queue queue : this.queues) {
        admin.deleteQueue(queue.getName());
    }//w  w w.  jav a  2  s  .co  m
    connectionFactory.destroy();
}

From source file:com.noriental.solr.config.test.BrokerRunning.java

@Override
public Statement apply(Statement base, Description description) {

    // Check at the beginning, so this can be used as a static field
    if (assumeOnline) {
        Assume.assumeTrue(brokerOnline.get(port));
    } else {/*from w w  w  .  j  a v a  2 s  .  co  m*/
        Assume.assumeTrue(brokerOffline.get(port));
    }

    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setHost("localhost");

    try {

        connectionFactory.setPort(port);
        if (StringUtils.hasText(hostName)) {
            connectionFactory.setHost(hostName);
        }
        RabbitAdmin admin = new RabbitAdmin(connectionFactory);

        for (Queue queue : queues) {
            String queueName = queue.getName();

            if (purge) {
                logger.debug("Deleting queue: " + queueName);
                // Delete completely - gets rid of consumers and bindings as well
                admin.deleteQueue(queueName);
            }

            if (isDefaultQueue(queueName)) {
                // Just for test probe.
                admin.deleteQueue(queueName);
            } else {
                admin.declareQueue(queue);
            }
        }
        brokerOffline.put(port, false);
        if (!assumeOnline) {
            Assume.assumeTrue(brokerOffline.get(port));
        }

        if (this.management) {
            Client client = new Client("http://localhost:15672/api/", "guest", "guest");
            if (!client.alivenessTest("/")) {
                throw new RuntimeException(
                        "Aliveness test failed for localhost:15672 guest/quest; " + "management not available");
            }
        }
    } catch (AmqpTimeoutException e) {
        fail("Timed out getting connection");
    } catch (Exception e) {
        logger.warn("Not executing tests because basic connectivity test failed", e);
        brokerOnline.put(port, false);
        if (assumeOnline) {
            Assume.assumeNoException(e);
        }
    } finally {
        connectionFactory.destroy();
    }

    return super.apply(base, description);

}

From source file:org.springframework.cloud.stream.binder.rabbit.RabbitBinderCleanerTests.java

@Test
public void testCleanStream() {
    final RabbitBindingCleaner cleaner = new RabbitBindingCleaner();
    final RestTemplate template = RabbitManagementUtils.buildRestTemplate("http://localhost:15672", "guest",
            "guest");
    final String stream1 = UUID.randomUUID().toString();
    String stream2 = stream1 + "-1";
    String firstQueue = null;// w  ww .  j ava  2 s  . c  om
    CachingConnectionFactory connectionFactory = rabbitWithMgmtEnabled.getResource();
    RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
    for (int i = 0; i < 5; i++) {
        String queue1Name = AbstractBinder.applyPrefix(BINDER_PREFIX, stream1 + ".default." + i);
        String queue2Name = AbstractBinder.applyPrefix(BINDER_PREFIX, stream2 + ".default." + i);
        if (firstQueue == null) {
            firstQueue = queue1Name;
        }
        URI uri = UriComponentsBuilder.fromUriString("http://localhost:15672/api/queues")
                .pathSegment("{vhost}", "{queue}").buildAndExpand("/", queue1Name).encode().toUri();
        template.put(uri, new AmqpQueue(false, true));
        uri = UriComponentsBuilder.fromUriString("http://localhost:15672/api/queues")
                .pathSegment("{vhost}", "{queue}").buildAndExpand("/", queue2Name).encode().toUri();
        template.put(uri, new AmqpQueue(false, true));
        uri = UriComponentsBuilder.fromUriString("http://localhost:15672/api/queues")
                .pathSegment("{vhost}", "{queue}")
                .buildAndExpand("/", AbstractBinder.constructDLQName(queue1Name)).encode().toUri();
        template.put(uri, new AmqpQueue(false, true));
        TopicExchange exchange = new TopicExchange(queue1Name);
        rabbitAdmin.declareExchange(exchange);
        rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue(queue1Name)).to(exchange).with(queue1Name));
        exchange = new TopicExchange(queue2Name);
        rabbitAdmin.declareExchange(exchange);
        rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue(queue2Name)).to(exchange).with(queue2Name));
    }
    final TopicExchange topic1 = new TopicExchange(
            AbstractBinder.applyPrefix(BINDER_PREFIX, stream1 + ".foo.bar"));
    rabbitAdmin.declareExchange(topic1);
    rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue(firstQueue)).to(topic1).with("#"));
    String foreignQueue = UUID.randomUUID().toString();
    rabbitAdmin.declareQueue(new Queue(foreignQueue));
    rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue(foreignQueue)).to(topic1).with("#"));
    final TopicExchange topic2 = new TopicExchange(
            AbstractBinder.applyPrefix(BINDER_PREFIX, stream2 + ".foo.bar"));
    rabbitAdmin.declareExchange(topic2);
    rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue(firstQueue)).to(topic2).with("#"));
    new RabbitTemplate(connectionFactory).execute(new ChannelCallback<Void>() {

        @Override
        public Void doInRabbit(Channel channel) throws Exception {
            String queueName = AbstractBinder.applyPrefix(BINDER_PREFIX, stream1 + ".default." + 4);
            String consumerTag = channel.basicConsume(queueName, new DefaultConsumer(channel));
            try {
                waitForConsumerStateNot(queueName, 0);
                cleaner.clean(stream1, false);
                fail("Expected exception");
            } catch (RabbitAdminException e) {
                assertThat(e).hasMessageContaining("Queue " + queueName + " is in use");
            }
            channel.basicCancel(consumerTag);
            waitForConsumerStateNot(queueName, 1);
            try {
                cleaner.clean(stream1, false);
                fail("Expected exception");
            } catch (RabbitAdminException e) {
                assertThat(e).hasMessageContaining("Cannot delete exchange ");
                assertThat(e).hasMessageContaining("; it has bindings:");
            }
            return null;
        }

        private void waitForConsumerStateNot(String queueName, int state) throws InterruptedException {
            int n = 0;
            URI uri = UriComponentsBuilder.fromUriString("http://localhost:15672/api/queues")
                    .pathSegment("{vhost}", "{queue}").buildAndExpand("/", queueName).encode().toUri();
            while (n++ < 100) {
                @SuppressWarnings("unchecked")
                Map<String, Object> queueInfo = template.getForObject(uri, Map.class);
                if (!queueInfo.get("consumers").equals(Integer.valueOf(state))) {
                    break;
                }
                Thread.sleep(100);
            }
            assertThat(n < 100).withFailMessage("Consumer state remained at " + state + " after 10 seconds");
        }

    });
    rabbitAdmin.deleteExchange(topic1.getName()); // easier than deleting the binding
    rabbitAdmin.declareExchange(topic1);
    rabbitAdmin.deleteQueue(foreignQueue);
    connectionFactory.destroy();
    Map<String, List<String>> cleanedMap = cleaner.clean(stream1, false);
    assertThat(cleanedMap).hasSize(2);
    List<String> cleanedQueues = cleanedMap.get("queues");
    // should *not* clean stream2
    assertThat(cleanedQueues).hasSize(10);
    for (int i = 0; i < 5; i++) {
        assertThat(cleanedQueues.get(i * 2)).isEqualTo(BINDER_PREFIX + stream1 + ".default." + i);
        assertThat(cleanedQueues.get(i * 2 + 1)).isEqualTo(BINDER_PREFIX + stream1 + ".default." + i + ".dlq");
    }
    List<String> cleanedExchanges = cleanedMap.get("exchanges");
    assertThat(cleanedExchanges).hasSize(6);

    // wild card *should* clean stream2
    cleanedMap = cleaner.clean(stream1 + "*", false);
    assertThat(cleanedMap).hasSize(2);
    cleanedQueues = cleanedMap.get("queues");
    assertThat(cleanedQueues).hasSize(5);
    for (int i = 0; i < 5; i++) {
        assertThat(cleanedQueues.get(i)).isEqualTo(BINDER_PREFIX + stream2 + ".default." + i);
    }
    cleanedExchanges = cleanedMap.get("exchanges");
    assertThat(cleanedExchanges).hasSize(6);
}

From source file:org.springframework.amqp.rabbit.core.RabbitAdminTests.java

@Test
public void testProperties() throws Exception {
    SingleConnectionFactory connectionFactory = new SingleConnectionFactory();
    connectionFactory.setHost("localhost");
    RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
    String queueName = "test.properties." + System.currentTimeMillis();
    try {//from w ww . j a  v a 2s .c o m
        rabbitAdmin.declareQueue(new Queue(queueName));
        new RabbitTemplate(connectionFactory).convertAndSend(queueName, "foo");
        int n = 0;
        while (n++ < 100 && messageCount(rabbitAdmin, queueName) == 0) {
            Thread.sleep(100);
        }
        assertTrue("Message count = 0", n < 100);
        Channel channel = connectionFactory.createConnection().createChannel(false);
        DefaultConsumer consumer = new DefaultConsumer(channel);
        channel.basicConsume(queueName, true, consumer);
        n = 0;
        while (n++ < 100 && messageCount(rabbitAdmin, queueName) > 0) {
            Thread.sleep(100);
        }
        assertTrue("Message count > 0", n < 100);
        Properties props = rabbitAdmin.getQueueProperties(queueName);
        assertNotNull(props.get(RabbitAdmin.QUEUE_CONSUMER_COUNT));
        assertEquals(1, props.get(RabbitAdmin.QUEUE_CONSUMER_COUNT));
        channel.close();
    } finally {
        rabbitAdmin.deleteQueue(queueName);
        connectionFactory.destroy();
    }
}

From source file:org.springframework.amqp.rabbit.core.RabbitAdminTests.java

private void cleanQueuesAndExchanges(RabbitAdmin rabbitAdmin) {
    rabbitAdmin.deleteQueue("testq.nonDur");
    rabbitAdmin.deleteQueue("testq.ad");
    rabbitAdmin.deleteQueue("testq.excl");
    rabbitAdmin.deleteQueue("testq.all");
    rabbitAdmin.deleteExchange("testex.nonDur");
    rabbitAdmin.deleteExchange("testex.ad");
    rabbitAdmin.deleteExchange("testex.all");
}

From source file:org.springframework.amqp.rabbit.core.RabbitAdminTests.java

@Test
public void testMultiEntities() {
    ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
    RabbitTemplate template = ctx.getBean(RabbitTemplate.class);
    template.convertAndSend("e1", "k1", "foo");
    template.convertAndSend("e2", "k2", "bar");
    template.convertAndSend("e3", "k3", "baz");
    template.convertAndSend("e4", "k4", "qux");
    assertEquals("foo", template.receiveAndConvert("q1"));
    assertEquals("bar", template.receiveAndConvert("q2"));
    assertEquals("baz", template.receiveAndConvert("q3"));
    assertEquals("qux", template.receiveAndConvert("q4"));
    RabbitAdmin admin = ctx.getBean(RabbitAdmin.class);
    admin.deleteQueue("q1");
    admin.deleteQueue("q2");
    admin.deleteQueue("q3");
    admin.deleteQueue("q4");
    admin.deleteExchange("e1");
    admin.deleteExchange("e2");
    admin.deleteExchange("e3");
    admin.deleteExchange("e4");
    assertNull(admin.getQueueProperties(ctx.getBean(Config.class).protypeQueueName));
    ctx.close();/*from   w w w .j  a  va  2  s.c o  m*/
}

From source file:org.springframework.amqp.rabbit.core.RabbitAdminTests.java

@Test
public void testAvoidHangAMQP_508() {
    CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
    RabbitAdmin admin = new RabbitAdmin(cf);
    String longName = new String(new byte[300]).replace('\u0000', 'x');
    try {/*www  .j  a v  a2  s .  c  o  m*/
        admin.declareQueue(new Queue(longName));
    } catch (Exception e) {
        e.printStackTrace();
    }
    String goodName = "foobar";
    admin.declareQueue(new Queue(goodName));
    assertNull(admin.getQueueProperties(longName));
    assertNotNull(admin.getQueueProperties(goodName));
    admin.deleteQueue(goodName);
    cf.destroy();
}

From source file:org.springframework.amqp.rabbit.retry.MissingIdRetryTests.java

@BeforeClass
@AfterClass/*w w  w . j a va  2  s .  c  o  m*/
public static void setupAndCleanUp() {
    RabbitAdmin admin = brokerIsRunning.getAdmin();
    admin.deleteQueue("retry.test.queue");
    admin.deleteExchange("retry.test.exchange");
}

From source file:org.springframework.integration.amqp.rule.BrokerRunning.java

@Override
public Statement apply(Statement base, Description description) {
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setHost("localhost");

    try {/*from   ww  w .j  ava2  s  . c  o m*/

        connectionFactory.setPort(PORT);

        RabbitAdmin admin = new RabbitAdmin(connectionFactory);

        for (Queue queue : queues) {
            String queueName = queue.getName();
            logger.info("Deleting queue: " + queueName);
            // Delete completely - gets rid of consumers and bindings as well
            admin.deleteQueue(queueName);

            if (!DEFAULT_QUEUE_NAME.getName().equals(queueName)) {
                admin.declareQueue(queue);
            }
        }

    } catch (final Exception e) {
        logger.warn("Not executing tests because basic connectivity test failed", e);
        Assume.assumeNoException(e);
    } finally {
        connectionFactory.destroy();
    }

    return super.apply(base, description);
}