com.rabbitmq.client.Method Java Examples

@Test(timeout = ONE_MINUTE_MS)
public void testDeclareIncompatibleExchangeFails() throws Exception {
  RabbitMqIO.Read read =
      RabbitMqIO.read().withExchange("IncompatibleExchange", "direct", "unused");
  try {
    doExchangeTest(new ExchangeTestPlan(read, 1), true);
    fail("Expected to have failed to declare an incompatible exchange");
  } catch (Exception e) {
    Throwable cause = Throwables.getRootCause(e);
    if (cause instanceof ShutdownSignalException) {
      ShutdownSignalException sse = (ShutdownSignalException) cause;
      Method reason = sse.getReason();
      if (reason instanceof com.rabbitmq.client.AMQP.Connection.Close) {
        com.rabbitmq.client.AMQP.Connection.Close close =
            (com.rabbitmq.client.AMQP.Connection.Close) reason;
        assertEquals("Expected failure is 530: not-allowed", 530, close.getReplyCode());
      } else {
        fail(
            "Unexpected ShutdownSignalException reason. Expected Connection.Close. Got: "
                + reason);
      }
    } else {
      fail("Expected to fail with ShutdownSignalException. Instead failed with " + cause);
    }
  }
}
 

private boolean validate(Object target, Object[] args) {
    if (args == null) {
        if (isDebug) {
            logger.debug("Expected arguments, but found none.");
        }
        return false;
    }
    if (args.length != 3) {
        if (isDebug) {
            logger.debug("Expected 3 arguments, but found {}", args.length);
        }
        return false;
    }
    Object method = args[0];
    if (method == null) {
        // valid, but this won't be null producer side
        return false;
    }
    if (!(method instanceof Method)) {
        if (isDebug) {
            logger.debug("Expected args[0] to be {}, but was {}", Method.class.getName(), method.getClass().getName());
        }
        return false;
    }
    if (!AMQP_METHOD_TO_INTERCEPT.equals(((Method) method).protocolMethodName())) {
        return false;
    }
    Object contentHeader = args[1];
    if (!(contentHeader instanceof AMQP.BasicProperties)) {
        // skip header injection for null, or non AMQP.BasicProperties header
        return false;
    }
    if (!(contentHeader instanceof HeadersFieldSetter)) {
        if (isDebug) {
            logger.debug("Invalid args[1]({}) object. Need field setter({})", contentHeader, HeadersFieldSetter.class.getName());
        }
        return false;
    }
    return true;
}
 

protected void callShutdownListener(RetryableResource resource, ShutdownSignalException e) {
  Method method = e.getReason();
  if (method instanceof AMQP.Connection.Close) {
    if (recoveryChannel != null)
      when(recoveryChannel.isOpen()).thenReturn(false);
    connectionHandler.shutdownListeners.get(0).shutdownCompleted(e);
  } else if (method instanceof AMQP.Channel.Close)
    resource.shutdownListeners.get(0).shutdownCompleted(e);
}
 

private static boolean isRetryable(ShutdownSignalException e) {
  if (e.isInitiatedByApplication())
    return false;
  Method method = e.getReason();
  if (method instanceof AMQP.Connection.Close)
    return isRetryable(((AMQP.Connection.Close) method).getReplyCode());
  if (method instanceof AMQP.Channel.Close)
    return isRetryable(((AMQP.Channel.Close) method).getReplyCode());
  return false;
}
 

@Override
public Command rpc(Method method) throws IOException {
    throw new UnsupportedOperationException(
            "This method is not currently supported as it is not used by current API in testing");
}
 

@Override
public void asyncRpc(Method method) throws IOException {
    delegate.asyncRpc(method);
}
 

@Override
public Command rpc(Method method) throws IOException {
    return delegate.rpc(method);
}
 

@Override
public CompletableFuture<Command> asyncCompletableRpc(Method method) throws IOException {
    return delegate.asyncCompletableRpc(method);
}
 

@Override
public void asyncRpc(Method method) throws IOException {
    throw new UnsupportedOperationException(
            "This method is not currently supported as it is not used by current API in testing");

}
 

@Override
public void asyncRpc(Method method) {
    throw new UnsupportedOperationException();
}
 

@Override
public void asyncRpc(Method method) throws IOException {
    throw new UnsupportedOperationException("This method is not currently supported as it is not used by current API in testing");

}
 

@Override
public Command rpc(Method method) throws IOException {
    throw new UnsupportedOperationException("This method is not currently supported as it is not used by current API in testing");
}
 

@Override
public CompletableFuture<Command> asyncCompletableRpc(Method method) throws IOException {
    throw new UnsupportedOperationException("This method is not currently supported as it is not used by current API in testing");
}
 

@Override
public CompletableFuture<Command> asyncCompletableRpc(Method method) {
    throw new UnsupportedOperationException();
}
 

protected ShutdownSignalException nonRetryableChannelShutdownSignal() {
  Method m = new AMQP.Channel.Close.Builder().replyCode(404).build();
  return new ShutdownSignalException(false, false, m, null);
}
 

protected ShutdownSignalException retryableChannelShutdownSignal() {
  Method m = new AMQP.Channel.Close.Builder().replyCode(311).build();
  return new ShutdownSignalException(false, false, m, null);
}
 

protected ShutdownSignalException retryableConnectionShutdownSignal() {
  Method m = new AMQP.Connection.Close.Builder().replyCode(320).build();
  return new ShutdownSignalException(true, false, m, null);
}
 

protected ShutdownSignalException nonRetryableConnectionShutdownSignal() {
  Method m = new AMQP.Connection.Close.Builder().replyCode(530).build();
  return new ShutdownSignalException(true, false, m, null);
}
 

@Override
public Command rpc(Method method) {
    throw new UnsupportedOperationException();
}