Package io.vertx.mutiny.rabbitmq

Class RabbitMQClient

java.lang.Object
io.vertx.mutiny.rabbitmq.RabbitMQClient
All Implemented Interfaces:
MutinyDelegate
public class RabbitMQClient extends Object implements MutinyDelegate

NOTE: This class has been automatically generated from the original non Mutiny-ified interface.

Author:
Nick Scavelli
See Also:
  • RabbitMQClient

  • Field Details

  • Constructor Details

    • RabbitMQClient

      public RabbitMQClient(io.vertx.rabbitmq.RabbitMQClient delegate)
      Create a new instance of RabbitMQClient delegating to the given (non-null) instance of RabbitMQClient.

    • RabbitMQClient

      public RabbitMQClient(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.rabbitmq.RabbitMQClient getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance

    • basicAck

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicAck(long deliveryTag, boolean multiple)
      Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being acknowledged.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.basicAck(long, boolean)
      • RabbitMQClient.basicAck(long, boolean)

    • basicAckAndAwait

      public void basicAckAndAwait(long deliveryTag, boolean multiple)
      Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being acknowledged.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.basicAck(long, boolean)
      • RabbitMQClient.basicAck(long, boolean)

    • basicAckAndForget

      public RabbitMQClient basicAckAndForget(long deliveryTag, boolean multiple)
      Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being acknowledged.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.basicAck(long, boolean)
      • RabbitMQClient.basicAck(long, boolean)

    • basicNack

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicNack(long deliveryTag, boolean multiple, boolean requeue)
      Reject one or several received messages.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.basicNack(long, boolean, boolean)
      • RabbitMQClient.basicNack(long, boolean, boolean)

    • basicNackAndAwait

      public void basicNackAndAwait(long deliveryTag, boolean multiple, boolean requeue)
      Reject one or several received messages.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.basicNack(long, boolean, boolean)
      • RabbitMQClient.basicNack(long, boolean, boolean)

    • basicNackAndForget

      public RabbitMQClient basicNackAndForget(long deliveryTag, boolean multiple, boolean requeue)
      Reject one or several received messages.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.basicNack(long, boolean, boolean)
      • RabbitMQClient.basicNack(long, boolean, boolean)

    • basicGet

      @CheckReturnValue public io.smallrye.mutiny.Uni<RabbitMQMessage> basicGet(String queue, boolean autoAck)
      Retrieve a message from a queue using AMQP.Basic.Get

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.basicGet(String, boolean)
      • RabbitMQClient.basicGet(String, boolean)

    • basicGetAndAwait

      public RabbitMQMessage basicGetAndAwait(String queue, boolean autoAck)
      Retrieve a message from a queue using AMQP.Basic.Get

      Unlike the bare Vert.x variant, this method returns a RabbitMQMessage. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • Channel.basicGet(String, boolean)
      • RabbitMQClient.basicGet(String, boolean)

    • basicGetAndForget

      public RabbitMQClient basicGetAndForget(String queue, boolean autoAck)
      Retrieve a message from a queue using AMQP.Basic.Get

      Unlike the bare Vert.x variant, this method ignores the RabbitMQMessage result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.basicGet(String, boolean)
      • RabbitMQClient.basicGet(String, boolean)

    • basicConsumer

      @CheckReturnValue public io.smallrye.mutiny.Uni<RabbitMQConsumer> basicConsumer(String queue)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • com.rabbitmq.client.Channel#basicConsume(String, Consumer)
      • basicConsumer(String)
      • RabbitMQClient.basicConsumer(String)

    • basicConsumerAndAwait

      public RabbitMQConsumer basicConsumerAndAwait(String queue)

      Unlike the bare Vert.x variant, this method returns a RabbitMQConsumer. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • com.rabbitmq.client.Channel#basicConsume(String, Consumer)
      • basicConsumer(String)
      • RabbitMQClient.basicConsumer(String)

    • basicConsumerAndForget

      public RabbitMQClient basicConsumerAndForget(String queue)

      Unlike the bare Vert.x variant, this method ignores the RabbitMQConsumer result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • com.rabbitmq.client.Channel#basicConsume(String, Consumer)
      • basicConsumer(String)
      • RabbitMQClient.basicConsumer(String)

    • basicConsumer

      @CheckReturnValue public io.smallrye.mutiny.Uni<RabbitMQConsumer> basicConsumer(String queue, io.vertx.rabbitmq.QueueOptions options)
      Create a consumer with the given options.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      queue - the name of a queue
      options - options for queue
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • com.rabbitmq.client.Channel#basicConsume(String, boolean, String, Consumer)
      • RabbitMQClient.basicConsumer(String, QueueOptions)

    • basicConsumerAndAwait

      public RabbitMQConsumer basicConsumerAndAwait(String queue, io.vertx.rabbitmq.QueueOptions options)
      Create a consumer with the given options.

      Unlike the bare Vert.x variant, this method returns a RabbitMQConsumer. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      queue - the name of a queue
      options - options for queue
      Returns:
      The operation result
      See Also:
      • com.rabbitmq.client.Channel#basicConsume(String, boolean, String, Consumer)
      • RabbitMQClient.basicConsumer(String, QueueOptions)

    • basicConsumerAndForget

      public RabbitMQClient basicConsumerAndForget(String queue, io.vertx.rabbitmq.QueueOptions options)
      Create a consumer with the given options.

      Unlike the bare Vert.x variant, this method ignores the RabbitMQConsumer result or any failure.

      Parameters:
      queue - the name of a queue
      options - options for queue
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • com.rabbitmq.client.Channel#basicConsume(String, boolean, String, Consumer)
      • RabbitMQClient.basicConsumer(String, QueueOptions)

    • basicPublish

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicPublish(String exchange, String routingKey, io.vertx.core.buffer.Buffer body)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublish(String, String, Buffer)

    • basicPublishAndAwait

      public void basicPublishAndAwait(String exchange, String routingKey, io.vertx.core.buffer.Buffer body)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublish(String, String, Buffer)

    • basicPublishAndForget

      public RabbitMQClient basicPublishAndForget(String exchange, String routingKey, io.vertx.core.buffer.Buffer body)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublish(String, String, Buffer)

    • basicPublish

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicPublish(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, io.vertx.core.buffer.Buffer body)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublish(String, String, BasicProperties, Buffer)

    • basicPublishAndAwait

      public void basicPublishAndAwait(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, io.vertx.core.buffer.Buffer body)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublish(String, String, BasicProperties, Buffer)

    • basicPublishAndForget

      public RabbitMQClient basicPublishAndForget(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, io.vertx.core.buffer.Buffer body)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublish(String, String, BasicProperties, Buffer)

    • basicPublishWithDeliveryTag

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicPublishWithDeliveryTag(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, io.vertx.core.buffer.Buffer body, Consumer<Long> deliveryTagHandler)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect. The deliveryTagHandler will be called before the message is sent, which is necessary because the confirmation may arrive asynchronously before the resultHandler is called.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      deliveryTagHandler - callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client before the result is known. Can be null.
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublishWithDeliveryTag(String, String, BasicProperties, Buffer, Handler)

    • basicPublishWithDeliveryTagAndAwait

      public void basicPublishWithDeliveryTagAndAwait(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, io.vertx.core.buffer.Buffer body, Consumer<Long> deliveryTagHandler)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect. The deliveryTagHandler will be called before the message is sent, which is necessary because the confirmation may arrive asynchronously before the resultHandler is called.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      deliveryTagHandler - callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client before the result is known.
      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublishWithDeliveryTag(String, String, BasicProperties, Buffer, Handler)

    • basicPublishWithDeliveryTagAndForget

      public RabbitMQClient basicPublishWithDeliveryTagAndForget(String exchange, String routingKey, com.rabbitmq.client.BasicProperties properties, io.vertx.core.buffer.Buffer body, Consumer<Long> deliveryTagHandler)
      Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect. The deliveryTagHandler will be called before the message is sent, which is necessary because the confirmation may arrive asynchronously before the resultHandler is called.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      deliveryTagHandler - callback to capture the deliveryTag for this message. Note that this will be called synchronously in the context of the client before the result is known.
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.basicPublish(String, String, AMQP.BasicProperties, byte[])
      • RabbitMQClient.basicPublishWithDeliveryTag(String, String, BasicProperties, Buffer, Handler)

    • addConfirmListener

      @CheckReturnValue public io.smallrye.mutiny.Uni<ReadStream<io.vertx.rabbitmq.RabbitMQConfirmation>> addConfirmListener(int maxQueueSize)
      Add a Confirm Listener to the channel. Note that this will automatically call confirmSelect, it is not necessary to call that too.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      maxQueueSize - maximum size of the queue of confirmations
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.addConfirmListener(ConfirmListener)
      • RabbitMQClient.addConfirmListener(int)

    • addConfirmListenerAndAwait

      public ReadStream<io.vertx.rabbitmq.RabbitMQConfirmation> addConfirmListenerAndAwait(int maxQueueSize)
      Add a Confirm Listener to the channel. Note that this will automatically call confirmSelect, it is not necessary to call that too.

      Unlike the bare Vert.x variant, this method returns a ReadStream<io.vertx.rabbitmq.RabbitMQConfirmation>. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      maxQueueSize - maximum size of the queue of confirmations
      Returns:
      The operation result
      See Also:
      • Channel.addConfirmListener(ConfirmListener)
      • RabbitMQClient.addConfirmListener(int)

    • addConfirmListenerAndForget

      public RabbitMQClient addConfirmListenerAndForget(int maxQueueSize)
      Add a Confirm Listener to the channel. Note that this will automatically call confirmSelect, it is not necessary to call that too.

      Unlike the bare Vert.x variant, this method ignores the ReadStream<io.vertx.rabbitmq.RabbitMQConfirmation> result or any failure.

      Parameters:
      maxQueueSize - maximum size of the queue of confirmations
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.addConfirmListener(ConfirmListener)
      • RabbitMQClient.addConfirmListener(int)

    • confirmSelect

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> confirmSelect()
      Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel#confirmSelect()
      • RabbitMQClient.confirmSelect()

    • confirmSelectAndAwait

      public void confirmSelectAndAwait()
      Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel#confirmSelect()
      • RabbitMQClient.confirmSelect()

    • confirmSelectAndForget

      public RabbitMQClient confirmSelectAndForget()
      Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel#confirmSelect()
      • RabbitMQClient.confirmSelect()

    • waitForConfirms

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> waitForConfirms()
      Wait until all messages published since the last call have been either ack'd or nack'd by the broker. This will incur slight performance loss at the expense of higher write consistency. If desired, multiple calls to basicPublish() can be batched before confirming.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      Throws - an IOException if the message was not written to the queue.
      See Also:
      • Channel#waitForConfirms()
      • RabbitMQClient.waitForConfirms()

    • waitForConfirmsAndAwait

      public void waitForConfirmsAndAwait()
      Wait until all messages published since the last call have been either ack'd or nack'd by the broker. This will incur slight performance loss at the expense of higher write consistency. If desired, multiple calls to basicPublish() can be batched before confirming.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Throws:
      Throws - an IOException if the message was not written to the queue.
      See Also:
      • Channel#waitForConfirms()
      • RabbitMQClient.waitForConfirms()

    • waitForConfirmsAndForget

      public RabbitMQClient waitForConfirmsAndForget()
      Wait until all messages published since the last call have been either ack'd or nack'd by the broker. This will incur slight performance loss at the expense of higher write consistency. If desired, multiple calls to basicPublish() can be batched before confirming.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      Throws:
      Throws - an IOException if the message was not written to the queue.
      See Also:
      • Channel#waitForConfirms()
      • RabbitMQClient.waitForConfirms()

    • waitForConfirms

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> waitForConfirms(long timeout)
      Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      timeout -
      Returns:
      A Uni representing the asynchronous result of this operation.
      Throws:
      Throws - an IOException if the message was not written to the queue.
      See Also:

    • waitForConfirmsAndAwait

      public void waitForConfirmsAndAwait(long timeout)
      Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      timeout -
      Throws:
      Throws - an IOException if the message was not written to the queue.
      See Also:

    • waitForConfirmsAndForget

      public RabbitMQClient waitForConfirmsAndForget(long timeout)
      Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      timeout -
      Returns:
      The current instance to chain operations if needed.
      Throws:
      Throws - an IOException if the message was not written to the queue.
      See Also:

    • basicQos

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicQos(int prefetchCount)
      Request a specific prefetchCount "quality of service" settings for this channel.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • basicQosAndAwait

      public void basicQosAndAwait(int prefetchCount)
      Request a specific prefetchCount "quality of service" settings for this channel.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      See Also:

    • basicQosAndForget

      public RabbitMQClient basicQosAndForget(int prefetchCount)
      Request a specific prefetchCount "quality of service" settings for this channel.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • basicQos

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicQos(int prefetchCount, boolean global)
      Request a specific prefetchCount "quality of service" settings for this channel.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      global - true if the settings should be applied to the entire channel rather than each consumer
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • basicQosAndAwait

      public void basicQosAndAwait(int prefetchCount, boolean global)
      Request a specific prefetchCount "quality of service" settings for this channel.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      global - true if the settings should be applied to the entire channel rather than each consumer
      See Also:

    • basicQosAndForget

      public RabbitMQClient basicQosAndForget(int prefetchCount, boolean global)
      Request a specific prefetchCount "quality of service" settings for this channel.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      global - true if the settings should be applied to the entire channel rather than each consumer
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • basicQos

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> basicQos(int prefetchSize, int prefetchCount, boolean global)
      Request specific "quality of service" settings. These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      prefetchSize - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      global - true if the settings should be applied to the entire channel rather than each consumer
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • AMQP.Basic.Qos
      • RabbitMQClient.basicQos(int, int, boolean)

    • basicQosAndAwait

      public void basicQosAndAwait(int prefetchSize, int prefetchCount, boolean global)
      Request specific "quality of service" settings. These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      prefetchSize - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      global - true if the settings should be applied to the entire channel rather than each consumer
      See Also:
      • AMQP.Basic.Qos
      • RabbitMQClient.basicQos(int, int, boolean)

    • basicQosAndForget

      public RabbitMQClient basicQosAndForget(int prefetchSize, int prefetchCount, boolean global)
      Request specific "quality of service" settings. These settings impose limits on the amount of data the server will deliver to consumers before requiring acknowledgements. Thus they provide a means of consumer-initiated flow control.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      prefetchSize - maximum amount of content (measured in octets) that the server will deliver, 0 if unlimited
      prefetchCount - maximum number of messages that the server will deliver, 0 if unlimited
      global - true if the settings should be applied to the entire channel rather than each consumer
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • AMQP.Basic.Qos
      • RabbitMQClient.basicQos(int, int, boolean)

    • exchangeDeclare

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete)
      Declare an exchange.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.exchangeDeclare(String, String, boolean, boolean, Map)
      • RabbitMQClient.exchangeDeclare(String, String, boolean, boolean)

    • exchangeDeclareAndAwait

      public void exchangeDeclareAndAwait(String exchange, String type, boolean durable, boolean autoDelete)
      Declare an exchange.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.exchangeDeclare(String, String, boolean, boolean, Map)
      • RabbitMQClient.exchangeDeclare(String, String, boolean, boolean)

    • exchangeDeclareAndForget

      public RabbitMQClient exchangeDeclareAndForget(String exchange, String type, boolean durable, boolean autoDelete)
      Declare an exchange.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.exchangeDeclare(String, String, boolean, boolean, Map)
      • RabbitMQClient.exchangeDeclare(String, String, boolean, boolean)

    • exchangeDeclare

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, io.vertx.core.json.JsonObject config)
      Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.exchangeDeclare(String, String, boolean, boolean, Map)
      • RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, JsonObject)

    • exchangeDeclareAndAwait

      public void exchangeDeclareAndAwait(String exchange, String type, boolean durable, boolean autoDelete, io.vertx.core.json.JsonObject config)
      Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.exchangeDeclare(String, String, boolean, boolean, Map)
      • RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, JsonObject)

    • exchangeDeclareAndForget

      public RabbitMQClient exchangeDeclareAndForget(String exchange, String type, boolean durable, boolean autoDelete, io.vertx.core.json.JsonObject config)
      Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.exchangeDeclare(String, String, boolean, boolean, Map)
      • RabbitMQClient.exchangeDeclare(String, String, boolean, boolean, JsonObject)

    • exchangeDelete

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> exchangeDelete(String exchange)
      Delete an exchange, without regard for whether it is in use or not.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.exchangeDelete(String)
      • RabbitMQClient.exchangeDelete(String)

    • exchangeDeleteAndAwait

      public void exchangeDeleteAndAwait(String exchange)
      Delete an exchange, without regard for whether it is in use or not.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.exchangeDelete(String)
      • RabbitMQClient.exchangeDelete(String)

    • exchangeDeleteAndForget

      public RabbitMQClient exchangeDeleteAndForget(String exchange)
      Delete an exchange, without regard for whether it is in use or not.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.exchangeDelete(String)
      • RabbitMQClient.exchangeDelete(String)

    • exchangeBind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> exchangeBind(String destination, String source, String routingKey)
      Bind an exchange to an exchange.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.exchangeBind(String, String, String)
      • RabbitMQClient.exchangeBind(String, String, String)

    • exchangeBindAndAwait

      public void exchangeBindAndAwait(String destination, String source, String routingKey)
      Bind an exchange to an exchange.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.exchangeBind(String, String, String)
      • RabbitMQClient.exchangeBind(String, String, String)

    • exchangeBindAndForget

      public RabbitMQClient exchangeBindAndForget(String destination, String source, String routingKey)
      Bind an exchange to an exchange.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.exchangeBind(String, String, String)
      • RabbitMQClient.exchangeBind(String, String, String)

    • exchangeBind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> exchangeBind(String destination, String source, String routingKey, Map<String,Object> arguments)
      Bind an exchange to an exchange.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.exchangeBind(String, String, String, Map<String, Object>)
      • RabbitMQClient.exchangeBind(String, String, String, Map)

    • exchangeBindAndAwait

      public void exchangeBindAndAwait(String destination, String source, String routingKey, Map<String,Object> arguments)
      Bind an exchange to an exchange.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.exchangeBind(String, String, String, Map<String, Object>)
      • RabbitMQClient.exchangeBind(String, String, String, Map)

    • exchangeBindAndForget

      public RabbitMQClient exchangeBindAndForget(String destination, String source, String routingKey, Map<String,Object> arguments)
      Bind an exchange to an exchange.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.exchangeBind(String, String, String, Map<String, Object>)
      • RabbitMQClient.exchangeBind(String, String, String, Map)

    • exchangeUnbind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> exchangeUnbind(String destination, String source, String routingKey)
      Unbind an exchange from an exchange.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.exchangeUnbind(String, String, String)
      • RabbitMQClient.exchangeUnbind(String, String, String)

    • exchangeUnbindAndAwait

      public void exchangeUnbindAndAwait(String destination, String source, String routingKey)
      Unbind an exchange from an exchange.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.exchangeUnbind(String, String, String)
      • RabbitMQClient.exchangeUnbind(String, String, String)

    • exchangeUnbindAndForget

      public RabbitMQClient exchangeUnbindAndForget(String destination, String source, String routingKey)
      Unbind an exchange from an exchange.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.exchangeUnbind(String, String, String)
      • RabbitMQClient.exchangeUnbind(String, String, String)

    • exchangeUnbind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> exchangeUnbind(String destination, String source, String routingKey, Map<String,Object> arguments)
      Unbind an exchange from an exchange.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.exchangeUnbind(String, String, String, Map<String, Object>)
      • RabbitMQClient.exchangeUnbind(String, String, String, Map)

    • exchangeUnbindAndAwait

      public void exchangeUnbindAndAwait(String destination, String source, String routingKey, Map<String,Object> arguments)
      Unbind an exchange from an exchange.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.exchangeUnbind(String, String, String, Map<String, Object>)
      • RabbitMQClient.exchangeUnbind(String, String, String, Map)

    • exchangeUnbindAndForget

      public RabbitMQClient exchangeUnbindAndForget(String destination, String source, String routingKey, Map<String,Object> arguments)
      Unbind an exchange from an exchange.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.exchangeUnbind(String, String, String, Map<String, Object>)
      • RabbitMQClient.exchangeUnbind(String, String, String, Map)

    • queueDeclareAuto

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> queueDeclareAuto()
      Actively declare a server-named exclusive, autodelete, non-durable queue.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueDeclare()
      • RabbitMQClient.queueDeclareAuto()

    • queueDeclareAutoAndAwait

      public io.vertx.core.json.JsonObject queueDeclareAutoAndAwait()
      Actively declare a server-named exclusive, autodelete, non-durable queue.

      Unlike the bare Vert.x variant, this method returns a JsonObject. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • Channel.queueDeclare()
      • RabbitMQClient.queueDeclareAuto()

    • queueDeclareAutoAndForget

      public RabbitMQClient queueDeclareAutoAndForget()
      Actively declare a server-named exclusive, autodelete, non-durable queue.

      Unlike the bare Vert.x variant, this method ignores the JsonObject result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueDeclare()
      • RabbitMQClient.queueDeclareAuto()

    • queueDeclare

      @CheckReturnValue public io.smallrye.mutiny.Uni<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete)
      Declare a queue

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
      • RabbitMQClient.queueDeclare(String, boolean, boolean, boolean)

    • queueDeclareAndAwait

      public com.rabbitmq.client.AMQP.Queue.DeclareOk queueDeclareAndAwait(String queue, boolean durable, boolean exclusive, boolean autoDelete)
      Declare a queue

      Unlike the bare Vert.x variant, this method returns a AMQP.Queue.DeclareOk. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
      • RabbitMQClient.queueDeclare(String, boolean, boolean, boolean)

    • queueDeclareAndForget

      public RabbitMQClient queueDeclareAndForget(String queue, boolean durable, boolean exclusive, boolean autoDelete)
      Declare a queue

      Unlike the bare Vert.x variant, this method ignores the AMQP.Queue.DeclareOk result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
      • RabbitMQClient.queueDeclare(String, boolean, boolean, boolean)

    • queueDeclare

      @CheckReturnValue public io.smallrye.mutiny.Uni<com.rabbitmq.client.AMQP.Queue.DeclareOk> queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, io.vertx.core.json.JsonObject config)
      Declare a queue with config options

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
      • RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, JsonObject)

    • queueDeclareAndAwait

      public com.rabbitmq.client.AMQP.Queue.DeclareOk queueDeclareAndAwait(String queue, boolean durable, boolean exclusive, boolean autoDelete, io.vertx.core.json.JsonObject config)
      Declare a queue with config options

      Unlike the bare Vert.x variant, this method returns a AMQP.Queue.DeclareOk. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
      • RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, JsonObject)

    • queueDeclareAndForget

      public RabbitMQClient queueDeclareAndForget(String queue, boolean durable, boolean exclusive, boolean autoDelete, io.vertx.core.json.JsonObject config)
      Declare a queue with config options

      Unlike the bare Vert.x variant, this method ignores the AMQP.Queue.DeclareOk result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueDeclare(String, boolean, boolean, boolean, java.util.Map)
      • RabbitMQClient.queueDeclare(String, boolean, boolean, boolean, JsonObject)

    • queueDelete

      @CheckReturnValue public io.smallrye.mutiny.Uni<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDelete(String queue)
      Delete a queue, without regard for whether it is in use or has messages on it

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueDelete(String)
      • RabbitMQClient.queueDelete(String)

    • queueDeleteAndAwait

      public com.rabbitmq.client.AMQP.Queue.DeleteOk queueDeleteAndAwait(String queue)
      Delete a queue, without regard for whether it is in use or has messages on it

      Unlike the bare Vert.x variant, this method returns a AMQP.Queue.DeleteOk. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • Channel.queueDelete(String)
      • RabbitMQClient.queueDelete(String)

    • queueDeleteAndForget

      public RabbitMQClient queueDeleteAndForget(String queue)
      Delete a queue, without regard for whether it is in use or has messages on it

      Unlike the bare Vert.x variant, this method ignores the AMQP.Queue.DeleteOk result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueDelete(String)
      • RabbitMQClient.queueDelete(String)

    • queueDeleteIf

      @CheckReturnValue public io.smallrye.mutiny.Uni<com.rabbitmq.client.AMQP.Queue.DeleteOk> queueDeleteIf(String queue, boolean ifUnused, boolean ifEmpty)
      Delete a queue

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueDelete(String, boolean, boolean)
      • RabbitMQClient.queueDeleteIf(String, boolean, boolean)

    • queueDeleteIfAndAwait

      public com.rabbitmq.client.AMQP.Queue.DeleteOk queueDeleteIfAndAwait(String queue, boolean ifUnused, boolean ifEmpty)
      Delete a queue

      Unlike the bare Vert.x variant, this method returns a AMQP.Queue.DeleteOk. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • Channel.queueDelete(String, boolean, boolean)
      • RabbitMQClient.queueDeleteIf(String, boolean, boolean)

    • queueDeleteIfAndForget

      public RabbitMQClient queueDeleteIfAndForget(String queue, boolean ifUnused, boolean ifEmpty)
      Delete a queue

      Unlike the bare Vert.x variant, this method ignores the AMQP.Queue.DeleteOk result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueDelete(String, boolean, boolean)
      • RabbitMQClient.queueDeleteIf(String, boolean, boolean)

    • queueBind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> queueBind(String queue, String exchange, String routingKey)
      Bind a queue to an exchange

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueBind(String, String, String)
      • RabbitMQClient.queueBind(String, String, String)

    • queueBindAndAwait

      public void queueBindAndAwait(String queue, String exchange, String routingKey)
      Bind a queue to an exchange

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.queueBind(String, String, String)
      • RabbitMQClient.queueBind(String, String, String)

    • queueBindAndForget

      public RabbitMQClient queueBindAndForget(String queue, String exchange, String routingKey)
      Bind a queue to an exchange

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueBind(String, String, String)
      • RabbitMQClient.queueBind(String, String, String)

    • queueBind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> queueBind(String queue, String exchange, String routingKey, Map<String,Object> arguments)
      Bind a queue to an exchange

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueBind(String, String, String, Map<String, Object>)
      • RabbitMQClient.queueBind(String, String, String, Map)

    • queueBindAndAwait

      public void queueBindAndAwait(String queue, String exchange, String routingKey, Map<String,Object> arguments)
      Bind a queue to an exchange

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.queueBind(String, String, String, Map<String, Object>)
      • RabbitMQClient.queueBind(String, String, String, Map)

    • queueBindAndForget

      public RabbitMQClient queueBindAndForget(String queue, String exchange, String routingKey, Map<String,Object> arguments)
      Bind a queue to an exchange

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueBind(String, String, String, Map<String, Object>)
      • RabbitMQClient.queueBind(String, String, String, Map)

    • queueUnbind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> queueUnbind(String queue, String exchange, String routingKey)
      Unbind a queue from an exchange

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueUnbind(String, String, String)
      • RabbitMQClient.queueUnbind(String, String, String)

    • queueUnbindAndAwait

      public void queueUnbindAndAwait(String queue, String exchange, String routingKey)
      Unbind a queue from an exchange

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.queueUnbind(String, String, String)
      • RabbitMQClient.queueUnbind(String, String, String)

    • queueUnbindAndForget

      public RabbitMQClient queueUnbindAndForget(String queue, String exchange, String routingKey)
      Unbind a queue from an exchange

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueUnbind(String, String, String)
      • RabbitMQClient.queueUnbind(String, String, String)

    • queueUnbind

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> queueUnbind(String queue, String exchange, String routingKey, Map<String,Object> arguments)
      Unbind a queue from an exchange

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.queueUnbind(String, String, String, Map<String, Object>)
      • RabbitMQClient.queueUnbind(String, String, String, Map)

    • queueUnbindAndAwait

      public void queueUnbindAndAwait(String queue, String exchange, String routingKey, Map<String,Object> arguments)
      Unbind a queue from an exchange

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Channel.queueUnbind(String, String, String, Map<String, Object>)
      • RabbitMQClient.queueUnbind(String, String, String, Map)

    • queueUnbindAndForget

      public RabbitMQClient queueUnbindAndForget(String queue, String exchange, String routingKey, Map<String,Object> arguments)
      Unbind a queue from an exchange

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.queueUnbind(String, String, String, Map<String, Object>)
      • RabbitMQClient.queueUnbind(String, String, String, Map)

    • messageCount

      @CheckReturnValue public io.smallrye.mutiny.Uni<Long> messageCount(String queue)
      Returns the number of messages in a queue ready to be delivered.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Channel.messageCount(String)
      • RabbitMQClient.messageCount(String)

    • messageCountAndAwait

      public Long messageCountAndAwait(String queue)
      Returns the number of messages in a queue ready to be delivered.

      Unlike the bare Vert.x variant, this method returns a Long. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Returns:
      The operation result
      See Also:
      • Channel.messageCount(String)
      • RabbitMQClient.messageCount(String)

    • messageCountAndForget

      public RabbitMQClient messageCountAndForget(String queue)
      Returns the number of messages in a queue ready to be delivered.

      Unlike the bare Vert.x variant, this method ignores the Long result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Channel.messageCount(String)
      • RabbitMQClient.messageCount(String)

    • start

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> start()
      Start the rabbitMQ client. Create the connection and the channel.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Connection.createChannel()
      • RabbitMQClient.start()

    • startAndAwait

      public void startAndAwait()
      Start the rabbitMQ client. Create the connection and the channel.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Connection.createChannel()
      • RabbitMQClient.start()

    • startAndForget

      public RabbitMQClient startAndForget()
      Start the rabbitMQ client. Create the connection and the channel.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Connection.createChannel()
      • RabbitMQClient.start()

    • stop

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> stop()
      Stop the rabbitMQ client. Close the connection and its channel.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Connection.close()
      • RabbitMQClient.stop()

    • stopAndAwait

      public void stopAndAwait()
      Stop the rabbitMQ client. Close the connection and its channel.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      See Also:
      • Connection.close()
      • RabbitMQClient.stop()

    • stopAndForget

      public RabbitMQClient stopAndForget()
      Stop the rabbitMQ client. Close the connection and its channel.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Connection.close()
      • RabbitMQClient.stop()

    • restartConnect

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> restartConnect(int attempts)
      restart the rabbitMQ connect.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      attempts - number of attempts
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • RabbitMQClient.restartConnect(int)

    • restartConnectAndAwait

      public void restartConnectAndAwait(int attempts)
      restart the rabbitMQ connect.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      attempts - number of attempts
      See Also:
      • RabbitMQClient.restartConnect(int)

    • restartConnectAndForget

      public RabbitMQClient restartConnectAndForget(int attempts)
      restart the rabbitMQ connect.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      attempts - number of attempts
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • RabbitMQClient.restartConnect(int)

    • create

      public static RabbitMQClient create(Vertx vertx)
      Create and return a client configured with the default options.
      Parameters:
      vertx - the vertx instance
      Returns:
      the client

    • create

      public static RabbitMQClient create(Vertx vertx, io.vertx.rabbitmq.RabbitMQOptions config)
      Create and return a client.
      Parameters:
      vertx - the vertx instance
      config - the client config
      Returns:
      the client

    • isConnected

      public boolean isConnected()
      Check if a connection is open
      Returns:
      true when the connection is open, false otherwise
      See Also:
      • ShutdownNotifier.isOpen()

    • isOpenChannel

      public boolean isOpenChannel()
      Check if a channel is open
      Returns:
      true when the connection is open, false otherwise
      See Also:
      • ShutdownNotifier.isOpen()

    • newInstance

      public static RabbitMQClient newInstance(io.vertx.rabbitmq.RabbitMQClient delegate)
      Creates a new instance of the RabbitMQClient.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object