object MqttPublisher
Factories for flows to publish to an MQTT broker
- Alphabetic
- By Inheritance
- MqttPublisher
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def doneFlow(connectionSettings: MqttConnectionSettings, concurrency: Int): Flow[MqttMessage, Done, MqttControl]
Create a flow which unconditionally publishes to MQTT with 'Done' as a pass-through value.
Create a flow which unconditionally publishes to MQTT with 'Done' as a pass-through value. This stage has the same semantics as 'orderedFlow'.
- def doneFlowWithContext[C](connectionSettings: MqttConnectionSettings, concurrency: Int): FlowWithContext[MqttMessage, C, Done, C, MqttControl]
Create a context-preserving flow which unconditionally publishes incoming messages to MQTT with a pass-through value of 'Done'.
Create a context-preserving flow which unconditionally publishes incoming messages to MQTT with a pass-through value of 'Done'. This stage has the same semantics as 'orderedFlow' and will fail on messages which don't specify a Quality of Service.
- def doneFlowWithContext[C](connectionSettings: MqttConnectionSettings, defaultQoS: MqttQoS, concurrency: Int): FlowWithContext[MqttMessage, C, Done, C, MqttControl]
Create a context-preserving flow which unconditionally publishes incoming messages to MQTT with a pass-through value of 'Done'.
Create a context-preserving flow which unconditionally publishes incoming messages to MQTT with a pass-through value of 'Done'. This stage has the same semantics as 'orderedFlow' and will apply the 'defaultQoS' to messages which don't specify a Quality of Service.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def flowWithContext[C, P](connectionSettings: MqttConnectionSettings, concurrency: Int): FlowWithContext[PublishWithPassThrough[P], C, P, C, MqttControl]
Context-preserving variant of
orderedFlow - def flowWithContext[C, P](connectionSettings: MqttConnectionSettings, defaultQoS: MqttQoS, concurrency: Int): FlowWithContext[PublishWithPassThrough[P], C, P, C, MqttControl]
Context-preserving variant of
orderedFlow - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def orderedFlow[P](connectionSettings: MqttConnectionSettings, concurrency: Int): Flow[PublishWithPassThrough[P], P, MqttControl]
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g.
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g. a checkpoint or offset to be committed) downstream. The pass-through being emitted may be treated as proof that the message to publish (if there is one) was published with the applicable QoS (atMostOnce will emit after the message has gone out "over the wire", atLeastOnce and exactlyOnce will emit after the broker has signalled acceptance of the message).
This stage will emit pass-throughs in the order received. This means that the emitted pass-through value signals that all messages to publish which came before the message were published, but conversely means potentially longer delays between successful publication and emission.
All incoming messages must specify a QoS; the stream will fail when encountering a message which doesn't specify a QoS.
The stage will backpressure if there are 'concurrency' elements in progress or waiting for emission.
Calling 'drain' on the materialized MqttControl will cause this stage to cancel demand and wait for in-flight publish attempts to complete before stopping. The returned future is completed when draining has started.
Calling 'shutdown' on the materialized MqttControl will cause the stage to immediately stop. In-flight publish attempts may or may not ultimately succeed.
- def orderedFlow[P](connectionSettings: MqttConnectionSettings, defaultQoS: MqttQoS, concurrency: Int): Flow[PublishWithPassThrough[P], P, MqttControl]
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g.
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g. a checkpoint or offset to be committed) downstream. The pass-through being emitted may be treated as proof that the message to publish (if there is one) was published with the applicable QoS (atMostOnce will emit after the message has gone out "over the wire", atLeastOnce and exactlyOnce will emit after the broker has signalled acceptance of the message).
This stage will emit pass-throughs in the order received. This means that the emitted pass-through value signals that all messages to publish which came before the message were published, but conversely means potentially longer delays between successful publication and emission.
Message-specific QoS values take precedence over the 'defaultQoS'.
The stage will backpressure if there are 'concurrency' elements in progress or waiting for emission.
Calling 'drain' on the materialized MqttControl will cause this stage to cancel demand and wait for in-flight publish attempts to complete before stopping. The returned future is completed when draining has started.
Calling 'shutdown' on the materialized MqttControl will cause the stage to immediately stop. In-flight publish attempts may or may not ultimately succeed.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unorderedFlow[P](connectionSettings: MqttConnectionSettings, concurrency: Int): Flow[PublishWithPassThrough[P], P, MqttControl]
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g.
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g. a checkpoint or offset to be committed) downstream. The pass-through being emitted may be treated as proof that the message to publish (if there is one) was published with the applicable QoS (atMostOnce will emit after the message has gone out "over the wire", atLeastOnce and exactlyOnce will emit after the broker has signalled acceptance of the message).
This stage might not emit pass-throughs in the order received: the emission of a particular pass-through does not suggest anything about whether any other message was published. In particular, checkpoints or offsets to be committed should not be used as pass-through values with this flow; this ability to reorder may mean less of a delay from successful publication to emission.
All incoming messages must specify a QoS; the stream will fail when encountering a message which doesn't specify a QoS.
This stage will backpressure if there are 'concurrency' elements in progress.
Calling 'drain' on the materialized MqttControl will cause this stage to cancel demand and wait for in-flight publish attempts to complete before stopping. The returned future is completed when draining has started.
Calling 'shutdown' on the materialized MqttControl will cause the stage to immediately stop. In-flight publish attempts may or may not ultimately succeed.
- def unorderedFlow[P](connectionSettings: MqttConnectionSettings, defaultQoS: MqttQoS, concurrency: Int): Flow[PublishWithPassThrough[P], P, MqttControl]
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g.
Create a flow which conditionally publishes to MQTT and emits a pass-through value (e.g. a checkpoint or offset to be committed) downstream. The pass-through being emitted may be treated as proof that the message to publish (if there is one) was published with the applicable QoS (atMostOnce will emit after the message has gone out "over the wire", atLeastOnce and exactlyOnce will emit after the broker has signalled acceptance of the message).
This stage might not emit pass-throughs in the order received: the emission of a particular pass-through does not suggest anything about whether any other message was published. In particular, checkpoints or offsets to be committed should not be used as pass-through values with this flow; this ability to reorder may mean less of a delay from successful publication to emission.
Message-specific QoS values take precedence over the 'defaultQoS'.
This stage will backpressure if there are 'concurrency' elements in progress.
Calling 'drain' on the materialized MqttControl will cause this stage to cancel demand and wait for in-flight publish attempts to complete before stopping. The returned future is completed when draining has started.
Calling 'shutdown' on the materialized MqttControl will cause the stage to immediately stop. In-flight publish attempts may or may not ultimately succeed.
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()