Packages

class RabbitMQClient extends AnyRef

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RabbitMQClient
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new RabbitMQClient(_asJava: AnyRef)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def asJava: AnyRef
  6. def basicAck(deliveryTag: Long, multiple: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Acknowledge one or several received messages.

    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.

  7. def basicAckFuture(deliveryTag: Long, multiple: Boolean): Future[JsonObject]

    Like basicAck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  8. def basicConsume(queue: String, address: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[Unit]], errorHandler: Handler[Throwable]): Unit

    Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler

  9. def basicConsume(queue: String, address: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.

  10. def basicConsume(queue: String, address: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.

  11. def basicConsumeFuture(queue: String, address: String, autoAck: Boolean): Future[Unit]

    Like basicConsume but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  12. def basicConsumeFuture(queue: String, address: String): Future[Unit]

    Like basicConsume but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  13. def basicGet(queue: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Retrieve a message from a queue using AMQP.Basic.Get

  14. def basicGetFuture(queue: String, autoAck: Boolean): Future[JsonObject]

    Like basicGet but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  15. def basicNack(deliveryTag: Long, multiple: Boolean, requeue: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Reject one or several received messages.

  16. def basicNackFuture(deliveryTag: Long, multiple: Boolean, requeue: Boolean): Future[JsonObject]

    Like basicNack but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  17. def basicPublish(exchange: String, routingKey: String, message: JsonObject, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Publish a message.

    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.

  18. def basicPublishFuture(exchange: String, routingKey: String, message: JsonObject): Future[Unit]

    Like basicPublish but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  19. def basicQos(prefetchCount: Int, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection).

    Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection). This limit is applied separately to each new consumer on the channel.

  20. def basicQosFuture(prefetchCount: Int): Future[Unit]

    Like basicQos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  21. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  22. def confirmSelect(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Enables publisher acknowledgements on this channel.

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

  23. def confirmSelectFuture(): Future[Unit]

    Like confirmSelect but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  24. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  25. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  26. def exchangeBind(destination: String, source: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Bind an exchange to an exchange.

  27. def exchangeBindFuture(destination: String, source: String, routingKey: String): Future[Unit]

    Like exchangeBind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  28. def exchangeDeclare(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, config: JsonObject, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.

  29. def exchangeDeclare(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Declare an exchange.

  30. def exchangeDeclareFuture(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, config: JsonObject): Future[Unit]

    Like exchangeDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  31. def exchangeDeclareFuture(exchange: String, type: String, durable: Boolean, autoDelete: Boolean): Future[Unit]

    Like exchangeDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  32. def exchangeDelete(exchange: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Delete an exchange, without regard for whether it is in use or not.

  33. def exchangeDeleteFuture(exchange: String): Future[Unit]

    Like exchangeDelete but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  34. def exchangeUnbind(destination: String, source: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Unbind an exchange from an exchange.

  35. def exchangeUnbindFuture(destination: String, source: String, routingKey: String): Future[Unit]

    Like exchangeUnbind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  36. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  37. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  38. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  39. def isConnected(): Boolean

    Check if a connection is open

    Check if a connection is open

    returns

    true when the connection is open, false otherwise

  40. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  41. def isOpenChannel(): Boolean

    Check if a channel is open

    Check if a channel is open

    returns

    true when the connection is open, false otherwise

  42. def messageCount(queue: String, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Returns the number of messages in a queue ready to be delivered.

  43. def messageCountFuture(queue: String): Future[JsonObject]

    Like messageCount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  44. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  45. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  46. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  47. def queueBind(queue: String, exchange: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Bind a queue to an exchange

  48. def queueBindFuture(queue: String, exchange: String, routingKey: String): Future[Unit]

    Like queueBind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  49. def queueDeclare(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, config: JsonObject, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Declare a queue with config options

  50. def queueDeclare(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Declare a queue

  51. def queueDeclareAuto(resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Actively declare a server-named exclusive, autodelete, non-durable queue.

  52. def queueDeclareAutoFuture(): Future[JsonObject]

    Like queueDeclareAuto but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  53. def queueDeclareFuture(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, config: JsonObject): Future[JsonObject]

    Like queueDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  54. def queueDeclareFuture(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean): Future[JsonObject]

    Like queueDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  55. def queueDelete(queue: String, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Delete a queue, without regard for whether it is in use or has messages on it

  56. def queueDeleteFuture(queue: String): Future[JsonObject]

    Like queueDelete but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  57. def queueDeleteIf(queue: String, ifUnused: Boolean, ifEmpty: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Delete a queue

  58. def queueDeleteIfFuture(queue: String, ifUnused: Boolean, ifEmpty: Boolean): Future[JsonObject]

    Like queueDeleteIf but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  59. def start(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Start the rabbitMQ client.

    Start the rabbitMQ client. Create the connection and the chanel.

  60. def startFuture(): Future[Unit]

    Like start but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  61. def stop(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Stop the rabbitMQ client.

    Stop the rabbitMQ client. Close the connection and its chanel.

  62. def stopFuture(): Future[Unit]

    Like stop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  63. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  64. def toString(): String
    Definition Classes
    AnyRef → Any
  65. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  66. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  67. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  68. def waitForConfirms(timeout: Long, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

    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.

  69. def waitForConfirms(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker.

    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.

  70. def waitForConfirmsFuture(timeout: Long): Future[Unit]

    Like waitForConfirms but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

  71. def waitForConfirmsFuture(): Future[Unit]

    Like waitForConfirms but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

Inherited from AnyRef

Inherited from Any

Ungrouped