Package

akka.stream.integration

activemq

Permalink

package activemq

Visibility

Public
All

Type Members

class AckedResponseFlow[A, B] extends AckedFlow[A, B]

Value Members

object AckActiveMqProducer
object AckBidiFlow
object AckFlow
object AckFlowOps
object AckSink
object ActiveMqConsumer
object ActiveMqFlow

This is a naive implementation of a bidirectional flow from/to ActiveMq; it assumes: - that a 1 on 1 correspondence (bijection) exists between elements sent to - and received from the BACK-END - that ordering is preserved between Out and In (see diagram); i.e.
This is a naive implementation of a bidirectional flow from/to ActiveMq; it assumes: - that a 1 on 1 correspondence (bijection) exists between elements sent to - and received from the BACK-END - that ordering is preserved between Out and In (see diagram); i.e. no mapAsyncUnordered, no foreachParallel, ideally no network-traversals; careful with dispatching to actors, etc. If this property cannot be upheld due to some stream-element's processing failing in an unexpected way, one will have to fail the graph - that at-least-once-delivery is acceptable on ActiveMqSink
This flow is practical for the typical use case of handling a request received from activemq, processing it with some bidi-flow, and dispatching a response to ActiveMq. The original requests gets acked once the response is sent.
```
LEGEND:

FRONT-END                          BACK-END
                 +-------------+
ActiveMqSource ~>|             |~> Out
                 | AckBidiFlow |
ActiveMqSink   <~|             |<~ In
                 +-------------+
```
object ActiveMqProducer
object ActiveMqReqRespFlow

This is a naive implementation of a bidirectional flow from/to ActiveMq using request-response; it assumes: - that a 1 on 1 correspondence (bijection) exists between elements sent to - and received from the BACK-END - that ordering is preserved between Out and In (see diagram); i.e.
This is a naive implementation of a bidirectional flow from/to ActiveMq using request-response; it assumes: - that a 1 on 1 correspondence (bijection) exists between elements sent to - and received from the BACK-END - that ordering is preserved between Out and In (see diagram); i.e. no mapAsyncUnordered, no foreachParallel, ideally no network-traversals; careful with dispatching to actors, etc. If this property cannot be upheld due to some stream-element's processing failing in an unexpected way, one will have to fail the graph - that at-least-once-delivery is acceptable on the response-destination
This flow is practical for the typical use case of handling a request received from activemq, processing it with some bidi-flow, and dispatching a response to ActiveMq. The original requests gets acked once the response is sent.
```
LEGEND:

FRONT-END                          BACK-END
                 +-------------+
ActiveMqSource ~>|             |~> Out
                 | AckBidiFlow |
Ackink         <~|             |<~ In
                 +-------------+
```
package extension

Ungrouped