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. 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
                 +-------------+

Linear Supertypes

AnyRef, Any

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def apply[S, T](consumerName: String, producerName: String, qos: Int = 8)(implicit arg0: CamelMessageExtractor[S], arg1: CamelMessageBuilder[T], ec: ExecutionContext, system: ActorSystem): Flow[T, S, ActorRef]

Create a bidi-flow that is linked up to an ActiveMqSource and ActiveMqSink by their configuration name
def apply[S, T, M1, M2](source: Source[AckUTup[S], M1], sink: Sink[AckUTup[T], M2])(implicit ec: ExecutionContext, system: ActorSystem): Flow[T, S, M1]

Create an acknowledging bi-directional flow, with its FRONT-END-in hooked up to source and its FRONT-END-out hooked up to sink.
Create an acknowledging bi-directional flow, with its FRONT-END-in hooked up to source and its FRONT-END-out hooked up to sink. This constructor is intended for cases where responses are sent to a fixed ActiveMq destination (i.e. the Sink)
def applyMat[S, T, M1, M2, Mat](source: Source[AckUTup[S], M1], sink: Sink[AckUTup[T], M2])(combineMat: (M1, M2) ⇒ Mat)(implicit ec: ExecutionContext, system: ActorSystem): Flow[T, S, Mat]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package activemq

object ActiveMqFlow

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[S, T](consumerName: String, producerName: String, qos: Int = 8)(implicit arg0: CamelMessageExtractor[S], arg1: CamelMessageBuilder[T], ec: ExecutionContext, system: ActorSystem): Flow[T, S, ActorRef]

def apply[S, T, M1, M2](source: Source[AckUTup[S], M1], sink: Sink[AckUTup[T], M2])(implicit ec: ExecutionContext, system: ActorSystem): Flow[T, S, M1]

def applyMat[S, T, M1, M2, Mat](source: Source[AckUTup[S], M1], sink: Sink[AckUTup[T], M2])(combineMat: (M1, M2) ⇒ Mat)(implicit ec: ExecutionContext, system: ActorSystem): Flow[T, S, Mat]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped