org.apache.pekko.stream.scaladsl

Fan-out the stream to several streams. Each upstream element is emitted to the first available downstream consumer. It will not shut down until the subscriptions for at least two downstream subscribers have been established.

A Balance has one in port and 2 or more out ports.

'''Emits when''' any of the outputs stops backpressuring; emits the element to the first available output

'''Backpressures when''' all of the outputs backpressure

'''Completes when''' upstream completes

'''Cancels when''' If eagerCancel is enabled: when any downstream cancels; otherwise: when all downstreams cancel

Fan-out the stream to several streams emitting each incoming upstream element to all downstream consumers. It will not shut down until the subscriptions for at least two downstream subscribers have been established.

'''Emits when''' all of the outputs stops backpressuring and there is an input element available

'''Backpressures when''' any of the outputs backpressure

'''Completes when''' upstream completes

'''Cancels when''' If eagerCancel is enabled: when any downstream cancels; otherwise: when all downstreams cancel

A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers. It consists of two parts, a Sink and a Source. The Sink broadcasts elements from a producer to the actually live consumers it has. Once the producer has been materialized, the Sink it feeds into returns a materialized value which is the corresponding Source. This Source can be materialized an arbitrary number of times, where each of the new materializations will receive their elements from the original Sink.

Takes multiple streams and outputs one stream formed from the input streams by first emitting all of the elements from the first stream and then emitting all of the elements from the second stream, etc.

A Concat has one first port, one second port and one out port.

'''Emits when''' the current stream has an element available; if the current input completes, it tries the next one

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete

'''Cancels when''' downstream cancels

Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them. Similar to Flow.fromSinkAndSource however that API does not connect the completion signals of the wrapped operators.

Allows to manage delay. Can be stateful to compute delay for any sequence of elements, as instances are not shared among running streams and all elements go through nextDelay(), updating state and returning delay for that element.

Factories to create sinks and sources from files

A Flow is a set of stream processing steps that has one open input and one open output.

Scala API: Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.

INTERNAL API: this trait will be changed in binary-incompatible ways for classes that are derived from it! Do not implement this interface outside the Pekko code base!

Binary compatibility is only maintained for callers of this trait’s interface.

INTERNAL API: this trait will be changed in binary-incompatible ways for classes that are derived from it! Do not implement this interface outside the Pekko code base!

Binary compatibility is only maintained for callers of this trait’s interface.

A flow that provides operations which automatically propagate the context of an element. Only a subset of common operations from FlowOps is supported. As an escape hatch you can use FlowWithContextOps.via to manually provide the context propagation for otherwise unsupported operations.

An "empty" flow can be created by calling FlowWithContext[Ctx, T].

Shared stream operations for FlowWithContext and SourceWithContext that automatically propagate a context element with each data element.

Interleave represents deterministic merge which takes N elements per input stream, in-order of inputs, emits them downstream and then cycles/"wraps-around" the inputs.

'''Emits when''' element is available from current input (depending on phase)

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete (eagerClose=false) or one upstream completes (eagerClose=true)

'''Cancels when''' downstream cancels

Provides JSON framing operators that can separate valid JSON objects from incoming pekko.util.ByteString objects.

Convenience functions for often-encountered purposes like keeping only the left (first) or only the right (second) of two input values.

Merge several streams, taking elements as they arrive from input streams (picking randomly when several have elements ready).

'''Emits when''' one of the inputs has an element available

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false

'''Cancels when''' downstream cancels

A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of producers. It consists of two parts, a Source and a Sink. The Source streams the element to a consumer from its merged inputs. Once the consumer has been materialized, the Source returns a materialized value which is the corresponding Sink. This Sink can then be materialized arbitrary many times, where each of the new materializations will feed its consumed elements to the original Source.

MergeLatest joins elements from N input streams into stream of lists of size N. i-th element in list is the latest emitted element from i-th input stream. MergeLatest emits list for each element emitted from some input stream, but only after each stream emitted at least one element

'''Emits when''' element is available from some input and each input emits at least one element from stream start

'''Completes when''' all upstreams complete (eagerClose=false) or one upstream completes (eagerClose=true)

'''Cancels when''' downstream cancels

Merge several streams, taking elements as they arrive from input streams (picking from preferred when several have elements ready).

A MergePreferred has one out port, one preferred input port and 1 or more secondary in ports.

'''Emits when''' one of the inputs has an element available, preferring a specified input if multiple have elements available

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false

'''Cancels when''' downstream cancels

Merge several streams, taking elements as they arrive from input streams (picking from prioritized once when several have elements ready).

A MergePrioritized has one out port, one or more input port with their priorities.

'''Emits when''' one of the inputs has an element available, preferring a input based on its priority if multiple have elements available

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false

'''Cancels when''' downstream cancels

Takes multiple streams whose elements in aggregate have a defined linear sequence with difference 1, starting at 0, and outputs a single stream containing these elements, in order. That is, given a set of input streams with combined elements e_k:

e₀, e₁, e₂, ..., e_n

This will output a stream ordered by k.

The elements in the input streams must already be sorted according to the sequence. The input streams do not need to be linear, but the aggregate stream must be linear, no element k may be skipped or duplicated, either of these conditions will cause the stream to fail.

The typical use case for this is to merge a partitioned stream back together while maintaining order. This can be achieved by first using zipWithIndex on the input stream, then partitioning using a Partition fanout, and then maintaining the index through the processing of each partition before bringing together with this stage.

'''Emits when''' one of the upstreams has the next expected element in the sequence available.

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete

'''Cancels when''' downstream cancels

Merge two pre-sorted streams such that the resulting stream is sorted.

'''Emits when''' both inputs have an element available

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete

'''Cancels when''' downstream cancels

Fan-out the stream to several streams. emitting an incoming upstream element to one downstream consumer according to the partitioner function applied to the element

Adheres to the ActorAttributes.SupervisionStrategy attribute.

'''Emits when''' emits when an element is available from the input and the chosen output has demand

'''Backpressures when''' the currently chosen output back-pressures

'''Completes when''' upstream completes and no output is pending

'''Cancels when''' all downstreams have cancelled (eagerCancel=false) or one downstream cancels (eagerCancel=true)

A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers. It consists of two parts, a Sink and a Source. The Sink e elements from a producer to the actually live consumers it has. The selection of consumer is done with a function. Each element can be routed to only one consumer. Once the producer has been materialized, the Sink it feeds into returns a materialized value which is the corresponding Source. This Source can be materialized an arbitrary number of times, where each of the new materializations will receive their elements from the original Sink.

A RestartFlow wraps a Flow that gets restarted when it completes or fails.

They are useful for graphs that need to run for longer than the Flow can necessarily guarantee it will, for example, for Flow streams that depend on a remote server that may crash or become partitioned. The RestartFlow ensures that the graph can continue running while the Flow restarts.

A RestartSink wraps a Sink that gets restarted when it completes or fails.

They are useful for graphs that need to run for longer than the Sink can necessarily guarantee it will, for example, for Sink streams that depend on a remote server that may crash or become partitioned. The RestartSink ensures that the graph can continue running while the Sink restarts.

A RestartSource wraps a Source that gets restarted when it completes or fails.

They are useful for graphs that need to run for longer than the Source can necessarily guarantee it will, for example, for Source streams that depend on a remote server that may crash or become partitioned. The RestartSource ensures that the graph can continue running while the Source restarts.

Flow with attached input and output, can be executed.

Allows access to an SSLSession with Scala types

A Sink is a set of stream processing steps that has one open input. Can be used as a Subscriber

This trait allows to have a queue as a sink for a stream. A SinkQueue pulls data from a stream with a backpressure mechanism.

This trait adds cancel support to SinkQueue.

A Source is a set of stream processing steps that has one open output. It can comprise any number of internal sources and transformations that are wired together, or it can be an “atomic” source, e.g. from a collection or a file. Materialization turns a Source into a Reactive Streams Publisher (at least conceptually).

This trait allows to have a queue as a data source for some stream.

This trait adds completion support to SourceQueue.

A source that provides operations which automatically propagate the context of an element. Only a subset of common operations from FlowOps is supported. As an escape hatch you can use FlowWithContextOps.via to manually provide the context propagation for otherwise unsupported operations.

Can be created by calling Source.asSourceWithContext

Converters for interacting with the blocking java.io streams APIs and Java 8 Streams

Factories for creating stream refs.

A “stream of streams” sub-flow of data elements, e.g. produced by groupBy. SubFlows cannot contribute to the super-flow’s materialized value since they are materialized later, during the runtime of the flow graph processing.

Stream cipher support based upon JSSE.

The underlying SSLEngine has four ports: plaintext input/output and ciphertext input/output. These are modeled as a pekko.stream.BidiShape element for use in stream topologies, where the plaintext ports are on the left hand side of the shape and the ciphertext ports on the right hand side.

Configuring JSSE is a rather complex topic, please refer to the JDK platform documentation or the excellent user guide that is part of the Play Framework documentation. The philosophy of this integration into Pekko Streams is to expose all knobs and dials to client code and therefore not limit the configuration possibilities. In particular the client code will have to provide the SSLEngine, which is typically created from a SSLContext. Handshake parameters and other parameters are defined when creating the SSLEngine.

'''IMPORTANT NOTE'''

The TLS specification until version 1.2 did not permit half-closing of the user data session that it transports—to be precise a half-close will always promptly lead to a full close. This means that canceling the plaintext output or completing the plaintext input of the SslTls operator will lead to full termination of the secure connection without regard to whether bytes are remaining to be sent or received, respectively. Especially for a client the common idiom of attaching a finite Source to the plaintext input and transforming the plaintext response bytes coming out will not work out of the box due to early termination of the connection. For this reason there is a parameter that determines whether the SslTls operator shall ignore completion and/or cancellation events, and the default is to ignore completion (in view of the client–server scenario). In order to terminate the connection the client will then need to cancel the plaintext output as soon as all expected bytes have been received. When ignoring both types of events the operator will shut down once both events have been received. See also TLSClosing. For now, half-closing is also not supported with TLS 1.3 where the spec allows it.

This object holds simple wrapping pekko.stream.scaladsl.BidiFlow implementations that can be used instead of TLS when no encryption is desired. The flows will just adapt the message protocol by wrapping into SessionBytes and unwrapping SendBytes.

Takes a stream of pair elements and splits each pair to two output streams.

An Unzip has one in port and one left and one right output port.

'''Emits when''' all of the outputs stop backpressuring and there is an input element available

'''Backpressures when''' any of the outputs backpressure

'''Completes when''' upstream completes

'''Cancels when''' any downstream cancels

Takes a stream of pair elements and splits each pair to two output streams.

An Unzip has one in port and one left and one right output port.

'''Emits when''' all of the outputs stop backpressuring and there is an input element available

'''Backpressures when''' any of the outputs backpressure

'''Completes when''' upstream completes

'''Cancels when''' any downstream cancels

Transforms each element of input stream into multiple streams using a splitter function.

'''Emits when''' all of the outputs stop backpressuring and there is an input element available

'''Backpressures when''' any of the outputs backpressure

'''Completes when''' upstream completes

'''Cancels when''' any downstream cancels

UnzipWith specialized for 10 outputs

UnzipWith specialized for 11 outputs

UnzipWith specialized for 12 outputs

UnzipWith specialized for 13 outputs

UnzipWith specialized for 14 outputs

UnzipWith specialized for 15 outputs

UnzipWith specialized for 16 outputs

UnzipWith specialized for 17 outputs

UnzipWith specialized for 18 outputs

UnzipWith specialized for 19 outputs

UnzipWith specialized for 2 outputs

UnzipWith specialized for 20 outputs

UnzipWith specialized for 21 outputs

UnzipWith specialized for 22 outputs

UnzipWith specialized for 3 outputs

UnzipWith specialized for 4 outputs

UnzipWith specialized for 5 outputs

UnzipWith specialized for 6 outputs

UnzipWith specialized for 7 outputs

UnzipWith specialized for 8 outputs

UnzipWith specialized for 9 outputs

Combine the elements of 2 streams into a stream of tuples.

A Zip has a left and a right input port and one out port

'''Emits when''' all of the inputs has an element available

'''Backpressures when''' downstream backpressures

'''Completes when''' any upstream completes

'''Cancels when''' downstream cancels

Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.

A ZipLatest has a left and a right input port and one out port.

No element is emitted until at least one element from each Source becomes available.

'''Emits when''' all of the inputs have at least an element available, and then each time an element becomes

• available on either of the inputs

'''Backpressures when''' downstream backpressures

'''Completes when''' any upstream completes if eagerComplete is enabled or wait for all upstreams to complete

'''Cancels when''' downstream cancels

Combine the elements of multiple streams into a stream of combined elements using a combiner function, picking always the latest of the elements of each source. The combined stream completes immediately if some upstreams have already completed while some upstreams did not emitted any value yet. If all upstreams produced some value and the optional parameter eagerComplete is true (default), the combined stream completes when any of the upstreams completes, otherwise, the combined stream will wait for all upstreams to complete.

No element is emitted until at least one element from each Source becomes available. Whenever a new element appears, the zipping function is invoked with a tuple containing the new element and the other last seen elements.

'''Emits when''' all of the inputs have at least an element available, and then each time an element becomes available on either of the inputs

'''Backpressures when''' downstream backpressures

'''Completes when''' any of the upstreams completes

'''Cancels when''' downstream cancels

ZipLatestWith specialized for 10 inputs