public AMQP.Exchange.UnbindOk exchangeUnbind(
String destination, String source, String routingKey, Map<String, Object> arguments)
throws IOException {
deleteRecordedExchangeBinding(destination, source, routingKey, arguments);
this.maybeDeleteRecordedAutoDeleteExchange(source);
return delegate.exchangeUnbind(destination, source, routingKey, arguments);
}
public AMQP.Queue.UnbindOk queueUnbind(
String queue, String exchange, String routingKey, Map<String, Object> arguments)
throws IOException {
deleteRecordedQueueBinding(queue, exchange, routingKey, arguments);
this.maybeDeleteRecordedAutoDeleteExchange(exchange);
return delegate.queueUnbind(queue, exchange, routingKey, arguments);
}
public void close(int closeCode, String closeMessage) throws IOException, TimeoutException {
try {
delegate.close(closeCode, closeMessage);
} finally {
this.connection.unregisterChannel(this);
}
}
public AMQP.Queue.BindOk queueBind(
String queue, String exchange, String routingKey, Map<String, Object> arguments)
throws IOException {
AMQP.Queue.BindOk ok = delegate.queueBind(queue, exchange, routingKey, arguments);
recordQueueBinding(queue, exchange, routingKey, arguments);
return ok;
}
public void close() throws IOException, TimeoutException {
try {
delegate.close();
} finally {
this.connection.unregisterChannel(this);
}
}
public AMQP.Exchange.BindOk exchangeBind(
String destination, String source, String routingKey, Map<String, Object> arguments)
throws IOException {
final AMQP.Exchange.BindOk ok =
delegate.exchangeBind(destination, source, routingKey, arguments);
recordExchangeBinding(destination, source, routingKey, arguments);
return ok;
}
public void basicQos(int prefetchSize, int prefetchCount, boolean global) throws IOException {
if (global) {
this.prefetchCountGlobal = prefetchCount;
} else {
this.prefetchCountConsumer = prefetchCount;
}
delegate.basicQos(prefetchSize, prefetchCount, global);
}
public void basicPublish(
String exchange,
String routingKey,
boolean mandatory,
AMQP.BasicProperties props,
byte[] body)
throws IOException {
delegate.basicPublish(exchange, routingKey, mandatory, props, body);
}
public String basicConsume(
String queue,
boolean autoAck,
String consumerTag,
boolean noLocal,
boolean exclusive,
Map<String, Object> arguments,
Consumer callback)
throws IOException {
final String result =
delegate.basicConsume(queue, autoAck, consumerTag, noLocal, exclusive, arguments, callback);
recordConsumer(result, queue, autoAck, exclusive, arguments, callback);
return result;
}
public void queueDeclareNoWait(
String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
Map<String, Object> arguments)
throws IOException {
RecordedQueue meta =
new RecordedQueue(this, queue)
.durable(durable)
.exclusive(exclusive)
.autoDelete(autoDelete)
.arguments(arguments);
delegate.queueDeclareNoWait(queue, durable, exclusive, autoDelete, arguments);
recordQueue(queue, meta);
}
@Override
public void exchangeDeclareNoWait(
String exchange,
String type,
boolean durable,
boolean autoDelete,
boolean internal,
Map<String, Object> arguments)
throws IOException {
RecordedExchange x =
new RecordedExchange(this, exchange)
.type(type)
.durable(durable)
.autoDelete(autoDelete)
.arguments(arguments);
recordExchange(exchange, x);
delegate.exchangeDeclareNoWait(exchange, type, durable, autoDelete, internal, arguments);
}
public AMQP.Exchange.DeclareOk exchangeDeclare(
String exchange,
String type,
boolean durable,
boolean autoDelete,
boolean internal,
Map<String, Object> arguments)
throws IOException {
final AMQP.Exchange.DeclareOk ok =
delegate.exchangeDeclare(exchange, type, durable, autoDelete, internal, arguments);
RecordedExchange x =
new RecordedExchange(this, exchange)
.type(type)
.durable(durable)
.autoDelete(autoDelete)
.arguments(arguments);
recordExchange(exchange, x);
return ok;
}
public AMQP.Queue.DeclareOk queueDeclare(
String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
Map<String, Object> arguments)
throws IOException {
final AMQP.Queue.DeclareOk ok =
delegate.queueDeclare(queue, durable, exclusive, autoDelete, arguments);
RecordedQueue q =
new RecordedQueue(this, ok.getQueue())
.durable(durable)
.exclusive(exclusive)
.autoDelete(autoDelete)
.arguments(arguments);
if (queue.equals(RecordedQueue.EMPTY_STRING)) {
q.serverNamed(true);
}
recordQueue(ok, q);
return ok;
}
public boolean waitForConfirms(long timeout) throws InterruptedException, TimeoutException {
return delegate.waitForConfirms(timeout);
}
public boolean isOpen() {
return delegate.isOpen();
}
public void notifyListeners() {
delegate.notifyListeners();
}
public ShutdownSignalException getCloseReason() {
return delegate.getCloseReason();
}
public void removeShutdownListener(ShutdownListener listener) {
this.shutdownHooks.remove(listener);
delegate.removeShutdownListener(listener);
}
/** @see Connection#addShutdownListener(com.rabbitmq.client.ShutdownListener) */
public void addShutdownListener(ShutdownListener listener) {
this.shutdownHooks.add(listener);
delegate.addShutdownListener(listener);
}
public Connection getConnection() {
return delegate.getConnection();
}
public Command rpc(Method method) throws IOException {
return delegate.rpc(method);
}
public void addReturnListener(ReturnListener listener) {
this.returnListeners.add(listener);
delegate.addReturnListener(listener);
}
public void abort() throws IOException {
delegate.abort();
}
public boolean waitForConfirms() throws InterruptedException {
return delegate.waitForConfirms();
}
@SuppressWarnings("deprecation")
@Deprecated
public boolean flowBlocked() {
return delegate.flowBlocked();
}
public void waitForConfirmsOrDie() throws IOException, InterruptedException {
delegate.waitForConfirmsOrDie();
}
public void abort(int closeCode, String closeMessage) throws IOException {
delegate.abort(closeCode, closeMessage);
}
public void waitForConfirmsOrDie(long timeout)
throws IOException, InterruptedException, TimeoutException {
delegate.waitForConfirmsOrDie(timeout);
}
public boolean removeReturnListener(ReturnListener listener) {
this.returnListeners.remove(listener);
return delegate.removeReturnListener(listener);
}
public void asyncRpc(Method method) throws IOException {
delegate.asyncRpc(method);
}
