lepus-client
0.5.1
API
Generated with
lepus-client/lepus.client/lepus.client.apis/ReliablePublishingMessagingChannel

ReliablePublishingMessagingChannel

lepus.client.apis.ReliablePublishingMessagingChannel
trait ReliablePublishingMessagingChannel[F[_]] extends MessagingChannel, Consuming[F], ReliablePublishing[F]

Attributes

Source
MessagingAPI.scala
Graph
Supertypes
trait Consuming[F]
class Object
trait Matchable
class Any
Show all

Members list

Value members

Inherited methods

def ack(deliveryTag: DeliveryTag, multiple: Boolean): F[Unit]

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def confirmations: Stream[F, Confirmation]

consumes Confirmation messages from the server, this should be used exclusively, or otherwise different instances compete over received values, and each get different set of values.

consumes Confirmation messages from the server, this should be used exclusively, or otherwise different instances compete over received values, and each get different set of values.

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
final def consume[T](queue: QueueName, mode: ConsumeMode, noLocal: NoLocal, exclusive: Boolean, arguments: FieldTable, consumerTag: Option[ConsumerTag])(using dec: MessageDecoder[T], F: RaiseThrowable[F]): Stream[F, DeliveredMessage[T]]

Consumes and decodes messages

Consumes and decodes messages

Note that you MUST acknowledge (ack, reject, nack) messages if you select any ConsumeMode but ConsumeMode.RaiseOnError(false)

Value parameters

arguments

extra params

consumerTag

add consumer tag, default tag is UUID

exclusive

request exclusive consumer right

mode

what to do when a message cannot be decoded

noLocal

don't consume messages published on this connection

queue

QueueName to consume from

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def consumeRaw(queue: QueueName, noLocal: NoLocal, noAck: NoAck, exclusive: Boolean, arguments: FieldTable, consumerTag: Option[ConsumerTag]): Stream[F, DeliveredMessageRaw]

Consumes raw messages

Consumes raw messages

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def get(queue: QueueName, noAck: NoAck): F[Option[SynchronousGetRaw]]

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def nack(deliveryTag: DeliveryTag, multiple: Boolean, requeue: Boolean): F[Unit]

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
final inline def publish[T : MessageEncoder](exchange: ExchangeName, routingKey: ShortString, payload: T)(implicit evidence$6: MessageEncoder[T], NotGiven[T <:< Message[_]]): F[DeliveryTag]

Creates a message that is not mandatory, encodes and publishes it

Creates a message that is not mandatory, encodes and publishes it

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
final inline def publish[T : MessageEncoder](exchange: ExchangeName, routingKey: ShortString, message: Message[T]): F[DeliveryTag]

Encodes and publishes a message that is not mandatory

Encodes and publishes a message that is not mandatory

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
final inline def publish[T : MessageEncoder](env: Envelope[T]): F[DeliveryTag]

Encodes and publishes an envelope, this is a low level operation and is exposed only for special circumstances, always prefer to use other higher level publish methods

Encodes and publishes an envelope, this is a low level operation and is exposed only for special circumstances, always prefer to use other higher level publish methods

Note that if a mandatory message fails in routing, it is returned to the client and you MUST also consume returned if you publish mandatory messages

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
final inline def publishRaw(exchange: ExchangeName, routingKey: ShortString, message: MessageRaw): F[DeliveryTag]

Publishes raw message that is not mandatory This is useful if you have handled encoding and want to publish a raw message directly

Publishes raw message that is not mandatory This is useful if you have handled encoding and want to publish a raw message directly

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
def publishRaw(env: EnvelopeRaw): F[DeliveryTag]

Publishes raw envelope, this is a low level operation and is exposed only for special circumstances, always prefer to use other higher level publish methods

Publishes raw envelope, this is a low level operation and is exposed only for special circumstances, always prefer to use other higher level publish methods

Note that if a mandatory message fails in routing, it is returned to the client and you MUST also consume returned if you publish mandatory messages

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
final def publisher[T : MessageEncoder](implicit evidence$7: MessageEncoder[T], Concurrent[F]): (F, Envelope[T]) => DeliveryTag | ReturnedMessageRaw

like publisherRaw, but encodes messages as well

like publisherRaw, but encodes messages as well

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
final def publisherRaw(using Concurrent[F]): (F, EnvelopeRaw) => DeliveryTag | ReturnedMessageRaw

A pipe that publishes Envelopes that may or may not be mandatory, And returns a delivery tag for every incoming message, and ReturnedMessageRaw for returned messages.

A pipe that publishes Envelopes that may or may not be mandatory, And returns a delivery tag for every incoming message, and ReturnedMessageRaw for returned messages.

Note that this pipe SHOULD be used exclusively, as it is draining from the returned messages that is backed by a queue.

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
def qos(prefetchSize: Int, prefetchCount: Short, global: Boolean): F[QosOk.type]

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def recover(requeue: Boolean): F[Unit]

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def recoverAsync(requeue: Boolean): F[Unit]

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def reject(deliveryTag: DeliveryTag, requeue: Boolean): F[Unit]

Attributes

Inherited from:
Consuming
Source
MessagingAPI.scala
def returned: Stream[F, ReturnedMessageRaw]

consumes returned messages from the server, this should be used exclusively, or otherwise different instances compete over received values, and each get different set of values.

consumes returned messages from the server, this should be used exclusively, or otherwise different instances compete over received values, and each get different set of values.

Also note that this is a low level operation that is exposed for special circumstances, always prefer to use publisher pipe instead, unless necessary

Attributes

Inherited from:
ReliablePublishing
Source
MessagingAPI.scala
Generated with