From 2226b839a6dc5c1e43fed63297b5adb15f085986 Mon Sep 17 00:00:00 2001 From: "mergify[bot]" Date: Tue, 3 Oct 2023 20:18:16 +0000 Subject: [PATCH] deploy: d019ab114f0bdb505ebf85dfdaf5157f98ef993c --- js/search.js | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/js/search.js b/js/search.js index 1c64b80..b2032da 100644 --- a/js/search.js +++ b/js/search.js @@ -53,9 +53,9 @@ function prepareIdxAndDocMap() { "content": "Auto Acknowledger Consumer A JmsAutoAcknowledgerConsumer is a consumer that will automatically acknowledge a message after its reception. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[AutoAckAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is an AutoAckAction[F], which can be either: an AckAction.noOp, which will instructs the lib to do nothing since the message will be acknowledged regardless an AckAction.send in all its forms, which can be used to send 1 or multiple messages to 1 or multiple destinations The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project." } , { - "title": "Acknowledger Consumer", - "url": "/jms4s/programs/ack-consumer/", - "content": "Acknowledger Consumer A JmsAcknowledgerConsumer is a consumer which let the client decide whether confirm (a.k.a. ack) or reject (a.k.a. nack) a message after its reception. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[AckAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is an AckAction[F], which can be either: an AckAction.ack, which will instructs the lib to confirm the message an AckAction.noAck, which will instructs the lib to do nothing an AckAction.send in all its forms, which can be used to instruct the lib to send 1 or multiple messages to 1 or multiple destinations The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project." + "title": "Transacted Consumer", + "url": "/jms4s/programs/tx-consumer/", + "content": "Transacted Consumer A JmsTransactedConsumer is a consumer that will use a local transaction to receive a message and which lets the client decide whether to commit or rollback it. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[TransactionAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is a TransactionAction[F], which can be either: a TransactionAction.commit, which will instructs the lib to commit the local transaction a TransactionAction.rollback, which will instructs the lib to rollback the local transaction a TransactionAction.send in all its forms, which can be used to send 1 or multiple messages to 1 or multiple destinations and then commit the local transaction The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project." } , { "title": "Producer", @@ -63,9 +63,9 @@ function prepareIdxAndDocMap() { "content": "Producer A JmsProducer is a producer that lets the client publish a message in queues/topics. sendN: to send N messages to N Destinations. def sendN( makeN: MessageFactory[F] => F[NonEmptyList[(JmsMessage, DestinationName)]] ): F[Unit] sendNWithDelay: to send N messages to N Destinations with an optional delay. def sendNWithDelay( makeNWithDelay: MessageFactory[F] => F[NonEmptyList[(JmsMessage, (DestinationName, Option[FiniteDuration]))]] ): F[Unit] sendWithDelay: to send a message to a Destination. def sendWithDelay( make1WithDelay: MessageFactory[F] => F[(JmsMessage, (DestinationName, Option[FiniteDuration]))] ): F[Unit] send: to send a message to a Destination. def send( make1: MessageFactory[F] => F[(JmsMessage, DestinationName)] ): F[Unit] For each operation, the client has to provide a function that knows how to build a JmsMessage given a MessageFactory. This may appear counter-intuitive at first, but the reason behind this design is that creating a JmsMessage is an operation that involves interacting with JMS APIs, and we want to provide a high-level API so that the user can’t do things wrong. A complete example is available in the example project. A note on concurrency A JmsProducer can be used concurrently, performing up to concurrencyLevel concurrent operation." } , { - "title": "Transacted Consumer", - "url": "/jms4s/programs/tx-consumer/", - "content": "Transacted Consumer A JmsTransactedConsumer is a consumer that will use a local transaction to receive a message and which lets the client decide whether to commit or rollback it. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[TransactionAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is a TransactionAction[F], which can be either: a TransactionAction.commit, which will instructs the lib to commit the local transaction a TransactionAction.rollback, which will instructs the lib to rollback the local transaction a TransactionAction.send in all its forms, which can be used to send 1 or multiple messages to 1 or multiple destinations and then commit the local transaction The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project." + "title": "Acknowledger Consumer", + "url": "/jms4s/programs/ack-consumer/", + "content": "Acknowledger Consumer A JmsAcknowledgerConsumer is a consumer which let the client decide whether confirm (a.k.a. ack) or reject (a.k.a. nack) a message after its reception. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[AckAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is an AckAction[F], which can be either: an AckAction.ack, which will instructs the lib to confirm the message an AckAction.noAck, which will instructs the lib to do nothing an AckAction.send in all its forms, which can be used to instruct the lib to send 1 or multiple messages to 1 or multiple destinations The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project." } , { "title": "Program",