public void testConnectionRecoveryWithArrayOfAddresses()
     throws IOException, InterruptedException, TimeoutException {
   final Address[] addresses = {new Address("127.0.0.1"), new Address("127.0.0.1", 5672)};
   AutorecoveringConnection c = newRecoveringConnection(addresses);
   try {
     assertTrue(c.isOpen());
     closeAndWaitForRecovery(c);
     assertTrue(c.isOpen());
   } finally {
     c.abort();
   }
 }
  public void testConsumerRecoveryWithManyConsumers() throws IOException, InterruptedException {
    String q =
        channel.queueDeclare(UUID.randomUUID().toString(), false, false, false, null).getQueue();
    final int n = 1024;
    for (int i = 0; i < n; i++) {
      channel.basicConsume(q, new DefaultConsumer(channel));
    }
    final AtomicReference<String> tagA = new AtomicReference<String>();
    final AtomicReference<String> tagB = new AtomicReference<String>();
    final CountDownLatch listenerLatch = new CountDownLatch(n);
    ((AutorecoveringConnection) connection)
        .addConsumerRecoveryListener(
            new ConsumerRecoveryListener() {
              @Override
              public void consumerRecovered(String oldConsumerTag, String newConsumerTag) {
                tagA.set(oldConsumerTag);
                tagB.set(newConsumerTag);
                listenerLatch.countDown();
              }
            });

    assertConsumerCount(n, q);
    closeAndWaitForRecovery();
    wait(listenerLatch);
    assertTrue(tagA.get().equals(tagB.get()));
    expectChannelRecovery(channel);
    assertConsumerCount(n, q);
  }
  public void testServerNamedQueueRecovery() throws IOException, InterruptedException {
    String q = channel.queueDeclare("", false, false, false, null).getQueue();
    String x = "amq.fanout";
    channel.queueBind(q, x, "");

    final AtomicReference<String> nameBefore = new AtomicReference<String>();
    final AtomicReference<String> nameAfter = new AtomicReference<String>();
    final CountDownLatch listenerLatch = new CountDownLatch(1);
    ((AutorecoveringConnection) connection)
        .addQueueRecoveryListener(
            new QueueRecoveryListener() {
              @Override
              public void queueRecovered(String oldName, String newName) {
                nameBefore.set(oldName);
                nameAfter.set(newName);
                listenerLatch.countDown();
              }
            });

    closeAndWaitForRecovery();
    wait(listenerLatch);
    expectChannelRecovery(channel);
    channel.basicPublish(x, "", null, "msg".getBytes());
    assertDelivered(q, 1);
    assertFalse(nameBefore.get().equals(nameAfter.get()));
    channel.queueDelete(q);
  }
 // bug 26552
 public void testServerNamedTransientAutoDeleteQueueAndBindingRecovery()
     throws IOException, InterruptedException, TimeoutException {
   String x = "tmp-fanout";
   Channel ch = connection.createChannel();
   ch.exchangeDelete(x);
   ch.exchangeDeclare(x, "fanout");
   String q = ch.queueDeclare("", false, false, true, null).getQueue();
   final AtomicReference<String> nameBefore = new AtomicReference<String>(q);
   final AtomicReference<String> nameAfter = new AtomicReference<String>();
   final CountDownLatch listenerLatch = new CountDownLatch(1);
   ((AutorecoveringConnection) connection)
       .addQueueRecoveryListener(
           new QueueRecoveryListener() {
             @Override
             public void queueRecovered(String oldName, String newName) {
               nameBefore.set(oldName);
               nameAfter.set(newName);
               listenerLatch.countDown();
             }
           });
   ch.queueBind(nameBefore.get(), x, "");
   restartPrimaryAndWaitForRecovery();
   expectChannelRecovery(ch);
   ch.confirmSelect();
   ch.exchangeDeclare(x, "fanout");
   ch.basicPublish(x, "", null, "msg".getBytes());
   waitForConfirms(ch);
   AMQP.Queue.DeclareOk ok = ch.queueDeclarePassive(nameAfter.get());
   assertEquals(1, ok.getMessageCount());
   ch.queueDelete(nameAfter.get());
   ch.exchangeDelete(x);
 }
 private CountDownLatch prepareForRecovery(Connection conn) {
   final CountDownLatch latch = new CountDownLatch(1);
   ((AutorecoveringConnection) conn)
       .addRecoveryListener(
           new RecoveryListener() {
             public void handleRecovery(Recoverable recoverable) {
               latch.countDown();
             }
           });
   return latch;
 }
  /**
   * Create a new broker connection with a client-provided name, picking the first available address
   * from the list provided by the {@link AddressResolver}.
   *
   * <p>If <a href="http://www.rabbitmq.com/api-guide.html#recovery">automatic connection
   * recovery</a> is enabled, the connection returned by this method will be {@link Recoverable}.
   * Future reconnection attempts will pick a random accessible address provided by the {@link
   * AddressResolver}.
   *
   * @param executor thread execution service for consumers on the connection
   * @param addressResolver discovery service to list potential addresses (hostname/port pairs) to
   *     connect to
   * @param clientProvidedName application-specific connection name, will be displayed in the
   *     management UI if RabbitMQ server supports it. This value doesn't have to be unique and
   *     cannot be used as a connection identifier e.g. in HTTP API requests. This value is supposed
   *     to be human-readable.
   * @return an interface to the connection
   * @throws java.io.IOException if it encounters a problem
   * @see <a href="http://www.rabbitmq.com/api-guide.html#recovery">Automatic Recovery</a>
   */
  public Connection newConnection(
      ExecutorService executor, AddressResolver addressResolver, String clientProvidedName)
      throws IOException, TimeoutException {
    if (this.metricsCollector == null) {
      this.metricsCollector = new NoOpMetricsCollector();
    }
    // make sure we respect the provided thread factory
    FrameHandlerFactory fhFactory = createFrameHandlerFactory();
    ConnectionParams params = params(executor);
    // set client-provided via a client property
    if (clientProvidedName != null) {
      Map<String, Object> properties = new HashMap<String, Object>(params.getClientProperties());
      properties.put("connection_name", clientProvidedName);
      params.setClientProperties(properties);
    }

    if (isAutomaticRecoveryEnabled()) {
      // see com.rabbitmq.client.impl.recovery.RecoveryAwareAMQConnectionFactory#newConnection
      AutorecoveringConnection conn =
          new AutorecoveringConnection(params, fhFactory, addressResolver, metricsCollector);

      conn.init();
      return conn;
    } else {
      List<Address> addrs = addressResolver.getAddresses();
      IOException lastException = null;
      for (Address addr : addrs) {
        try {
          FrameHandler handler = fhFactory.create(addr);
          AMQConnection conn = new AMQConnection(params, handler, metricsCollector);
          conn.start();
          this.metricsCollector.newConnection(conn);
          return conn;
        } catch (IOException e) {
          lastException = e;
        }
      }
      throw (lastException != null) ? lastException : new IOException("failed to connect");
    }
  }
 public void testConnectionRecoveryWithDisabledTopologyRecovery()
     throws IOException, InterruptedException, TimeoutException {
   AutorecoveringConnection c = newRecoveringConnection(true);
   Channel ch = c.createChannel();
   String q = "java-client.test.recovery.q2";
   ch.queueDeclare(q, false, true, false, null);
   ch.queueDeclarePassive(q);
   assertTrue(c.isOpen());
   try {
     CountDownLatch shutdownLatch = prepareForShutdown(c);
     CountDownLatch recoveryLatch = prepareForRecovery(c);
     Host.closeConnection(c);
     wait(shutdownLatch);
     wait(recoveryLatch);
     assertTrue(c.isOpen());
     ch.queueDeclarePassive(q);
     fail("expected passive declaration to throw");
   } catch (java.io.IOException e) {
     // expected
   } finally {
     c.abort();
   }
 }
  public void testBasicAckAfterChannelRecovery()
      throws IOException, InterruptedException, TimeoutException {
    final AtomicInteger consumed = new AtomicInteger(0);
    int n = 5;
    final CountDownLatch latch = new CountDownLatch(n);
    Consumer consumer =
        new DefaultConsumer(channel) {
          @Override
          public void handleDelivery(
              String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
              throws IOException {
            try {
              if (consumed.intValue() > 0 && consumed.intValue() % 4 == 0) {
                CountDownLatch recoveryLatch = prepareForRecovery(connection);
                Host.closeConnection((AutorecoveringConnection) connection);
                ConnectionRecovery.wait(recoveryLatch);
              }
              channel.basicAck(envelope.getDeliveryTag(), false);
            } catch (InterruptedException e) {
              // ignore
            } finally {
              consumed.incrementAndGet();
              latch.countDown();
            }
          }
        };

    String q = channel.queueDeclare().getQueue();
    channel.basicConsume(q, consumer);
    AutorecoveringConnection publishingConnection = newRecoveringConnection(false);
    Channel publishingChannel = publishingConnection.createChannel();
    for (int i = 0; i < n; i++) {
      publishingChannel.basicPublish("", q, null, "msg".getBytes());
    }
    wait(latch);
    publishingConnection.abort();
  }
 public void testNamedConnectionRecovery()
     throws IOException, InterruptedException, TimeoutException {
   String connectionName = "custom name";
   AutorecoveringConnection c = newRecoveringConnection(connectionName);
   try {
     assertTrue(c.isOpen());
     assertEquals(connectionName, c.getClientProvidedName());
     closeAndWaitForRecovery(c);
     assertTrue(c.isOpen());
     assertEquals(connectionName, c.getClientProvidedName());
   } finally {
     c.abort();
   }
 }