package scaladsl
Scala API: The flow DSL allows the formulation of stream transformations based on some input. The starting point is called Source and can be a collection, an iterator, a block of code which is evaluated repeatedly or a org.reactivestreams.Publisher. A flow with an attached input and open output is also a Source.
A flow may also be defined without an attached input or output and that is then
a Flow. The Flow
can be connected to the Source
later by using Source#via with
the flow as argument, and it remains a Source.
Transformations can be appended to Source
and Flow
with the operations
defined in FlowOps. Each DSL element produces a new flow that can be further transformed,
building up a description of the complete transformation pipeline.
The termination point of a flow is called Sink and can for example be a Future
or
org.reactivestreams.Subscriber. A flow with an attached output and open input
is also a Sink.
If a flow has both an attached input and an attached output it becomes a RunnableGraph. In order to execute this pipeline the flow must be materialized by calling RunnableGraph#run on it.
You can create your Source
, Flow
and Sink
in any order and then wire them together before
they are materialized by connecting them using Flow#via and Flow#to, or connecting them into a
GraphDSL with fan-in and fan-out elements.
See Reactive Streams for details on org.reactivestreams.Publisher and org.reactivestreams.Subscriber.
It should be noted that the streams modeled by this library are “hot”, meaning that they asynchronously flow through a series of processors without detailed control by the user. In particular it is not predictable how many elements a given transformation step might buffer before handing elements downstream, which means that transformation functions may be invoked more often than for corresponding transformations on strict collections like List. *An important consequence* is that elements that were produced into a stream may be discarded by later processors, e.g. when using the #take combinator.
By default every operation is executed within its own akka.actor.Actor to enable full pipelining of the chained set of computations. This behavior is determined by the akka.stream.Materializer which is required by those methods that materialize the Flow into a series of org.reactivestreams.Processor instances. The returned reactive stream is fully started and active.
- Source
- package.scala
- Alphabetic
- By Inheritance
- scaladsl
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
final
class
Balance
[T] extends GraphStage[UniformFanOutShape[T, T]]
Fan-out the stream to several streams.
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 onein
port and 2 or moreout
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 all downstreams cancel
- final class BidiFlow [-I1, +O1, -I2, +O2, +Mat] extends Graph[BidiShape[I1, O1, I2, O2], Mat]
-
final
class
Broadcast
[T] extends GraphStage[UniformFanOutShape[T, T]]
Fan-out the stream to several streams emitting each incoming upstream element to all downstream consumers.
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
-
final
class
Concat
[T] extends GraphStage[UniformFanInShape[T, T]]
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.
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 onefirst
port, onesecond
port and oneout
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
-
final
class
Flow
[-In, +Out, +Mat] extends FlowOpsMat[Out, Mat] with Graph[FlowShape[In, Out], Mat]
A
Flow
is a set of stream processing steps that has one open input and one open output. -
trait
FlowOps
[+Out, +Mat] extends AnyRef
Scala API: Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.
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 Akka code base!
Binary compatibility is only maintained for callers of this trait’s interface.
- Annotations
- @DoNotInherit()
-
trait
FlowOpsMat
[+Out, +Mat] extends FlowOps[Out, Mat]
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 Akka code base!
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 Akka code base!
Binary compatibility is only maintained for callers of this trait’s interface.
- trait GraphApply extends AnyRef
-
final
class
Interleave
[T] extends GraphStage[UniformFanInShape[T, T]]
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.
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
-
final
class
Merge
[T] extends GraphStage[UniformFanInShape[T, T]]
Merge several streams, taking elements as they arrive from input streams (picking randomly when several have elements ready).
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
-
final
class
MergePreferred
[T] extends GraphStage[MergePreferredShape[T]]
Merge several streams, taking elements as they arrive from input streams (picking from preferred when several have elements ready).
Merge several streams, taking elements as they arrive from input streams (picking from preferred when several have elements ready).
A
MergePreferred
has oneout
port, onepreferred
input port and 0 or more secondaryin
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
A
Broadcast
has onein
port and 2 or moreout
ports. -
final
class
MergeSorted
[T] extends GraphStage[FanInShape2[T, T, T]]
Merge two pre-sorted streams such that the resulting stream is sorted.
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
-
final
class
Partition
[T] extends GraphStage[UniformFanOutShape[T, T]]
Fan-out the stream to several streams.
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
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 when all downstreams cancel
-
final
case class
RunnableGraph
[+Mat](module: Module) extends Graph[ClosedShape, Mat] with Product with Serializable
Flow with attached input and output, can be executed.
-
trait
ScalaSessionAPI
extends AnyRef
Allows access to an SSLSession with Scala types
-
final
class
Sink
[-In, +Mat] extends Graph[SinkShape[In], Mat]
A
Sink
is a set of stream processing steps that has one open input.A
Sink
is a set of stream processing steps that has one open input. Can be used as aSubscriber
-
trait
SinkQueue
[T] extends AnyRef
Trait allows to have the queue as a sink for some stream.
Trait allows to have the queue as a sink for some stream. "SinkQueue" pulls data from stream with backpressure mechanism.
-
trait
SinkQueueWithCancel
[T] extends SinkQueue[T]
This trait adds cancel support to SinkQueue.
- implicit final class SinkToCompletionStage [In, T] extends AnyVal
-
final
class
Source
[+Out, +Mat] extends FlowOpsMat[Out, Mat] with Graph[SourceShape[Out], Mat]
A
Source
is a set of stream processing steps that has one open output.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 StreamsPublisher
(at least conceptually). -
trait
SourceQueue
[T] extends AnyRef
This trait allows to have the queue as a data source for some stream.
-
trait
SourceQueueWithComplete
[T] extends SourceQueue[T]
This trait adds completion support to SourceQueue.
- implicit final class SourceToCompletionStage [Out, T] extends AnyVal
-
trait
SubFlow
[+Out, +Mat, +F[+_], C] extends FlowOps[Out, Mat]
A “stream of streams” sub-flow of data elements, e.g.
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. - final class Tcp extends Extension
- final class TcpIdleTimeoutException extends TimeoutException
-
final
class
Unzip
[A, B] extends UnzipWith2[(A, B), A, B]
Combine the elements of multiple streams into a stream of the combined elements.
-
class
UnzipWith10
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10] extends GraphStage[FanOutShape10[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]]
UnzipWith
specialized for 10 outputs -
class
UnzipWith11
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11] extends GraphStage[FanOutShape11[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]]
UnzipWith
specialized for 11 outputs -
class
UnzipWith12
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12] extends GraphStage[FanOutShape12[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]]
UnzipWith
specialized for 12 outputs -
class
UnzipWith13
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13] extends GraphStage[FanOutShape13[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]]
UnzipWith
specialized for 13 outputs -
class
UnzipWith14
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14] extends GraphStage[FanOutShape14[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]]
UnzipWith
specialized for 14 outputs -
class
UnzipWith15
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15] extends GraphStage[FanOutShape15[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]]
UnzipWith
specialized for 15 outputs -
class
UnzipWith16
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16] extends GraphStage[FanOutShape16[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]]
UnzipWith
specialized for 16 outputs -
class
UnzipWith17
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17] extends GraphStage[FanOutShape17[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17]]
UnzipWith
specialized for 17 outputs -
class
UnzipWith18
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18] extends GraphStage[FanOutShape18[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18]]
UnzipWith
specialized for 18 outputs -
class
UnzipWith19
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19] extends GraphStage[FanOutShape19[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19]]
UnzipWith
specialized for 19 outputs -
class
UnzipWith2
[In, A1, A2] extends GraphStage[FanOutShape2[In, A1, A2]]
UnzipWith
specialized for 2 outputs -
class
UnzipWith20
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20] extends GraphStage[FanOutShape20[In, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20]]
UnzipWith
specialized for 20 outputs -
class
UnzipWith3
[In, A1, A2, A3] extends GraphStage[FanOutShape3[In, A1, A2, A3]]
UnzipWith
specialized for 3 outputs -
class
UnzipWith4
[In, A1, A2, A3, A4] extends GraphStage[FanOutShape4[In, A1, A2, A3, A4]]
UnzipWith
specialized for 4 outputs -
class
UnzipWith5
[In, A1, A2, A3, A4, A5] extends GraphStage[FanOutShape5[In, A1, A2, A3, A4, A5]]
UnzipWith
specialized for 5 outputs -
class
UnzipWith6
[In, A1, A2, A3, A4, A5, A6] extends GraphStage[FanOutShape6[In, A1, A2, A3, A4, A5, A6]]
UnzipWith
specialized for 6 outputs -
class
UnzipWith7
[In, A1, A2, A3, A4, A5, A6, A7] extends GraphStage[FanOutShape7[In, A1, A2, A3, A4, A5, A6, A7]]
UnzipWith
specialized for 7 outputs -
class
UnzipWith8
[In, A1, A2, A3, A4, A5, A6, A7, A8] extends GraphStage[FanOutShape8[In, A1, A2, A3, A4, A5, A6, A7, A8]]
UnzipWith
specialized for 8 outputs -
class
UnzipWith9
[In, A1, A2, A3, A4, A5, A6, A7, A8, A9] extends GraphStage[FanOutShape9[In, A1, A2, A3, A4, A5, A6, A7, A8, A9]]
UnzipWith
specialized for 9 outputs - trait UnzipWithApply extends AnyRef
-
final
class
Zip
[A, B] extends ZipWith2[A, B, (A, B)]
Combine the elements of 2 streams into a stream of tuples.
Combine the elements of 2 streams into a stream of tuples.
A
Zip
has aleft
and aright
input port and oneout
portEmits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
-
final
class
ZipN
[A] extends ZipWithN[A, Seq[A]]
Combine the elements of multiple streams into a stream of sequences.
Combine the elements of multiple streams into a stream of sequences.
A
ZipN
has an
input ports and oneout
portEmits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
-
class
ZipWith10
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O] extends GraphStage[FanInShape10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, O]]
ZipWith
specialized for 10 inputs -
class
ZipWith11
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O] extends GraphStage[FanInShape11[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, O]]
ZipWith
specialized for 11 inputs -
class
ZipWith12
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O] extends GraphStage[FanInShape12[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, O]]
ZipWith
specialized for 12 inputs -
class
ZipWith13
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O] extends GraphStage[FanInShape13[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, O]]
ZipWith
specialized for 13 inputs -
class
ZipWith14
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O] extends GraphStage[FanInShape14[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, O]]
ZipWith
specialized for 14 inputs -
class
ZipWith15
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O] extends GraphStage[FanInShape15[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, O]]
ZipWith
specialized for 15 inputs -
class
ZipWith16
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O] extends GraphStage[FanInShape16[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, O]]
ZipWith
specialized for 16 inputs -
class
ZipWith17
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O] extends GraphStage[FanInShape17[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, O]]
ZipWith
specialized for 17 inputs -
class
ZipWith18
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O] extends GraphStage[FanInShape18[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, O]]
ZipWith
specialized for 18 inputs -
class
ZipWith19
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O] extends GraphStage[FanInShape19[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, O]]
ZipWith
specialized for 19 inputs -
class
ZipWith2
[A1, A2, O] extends GraphStage[FanInShape2[A1, A2, O]]
ZipWith
specialized for 2 inputs -
class
ZipWith20
[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O] extends GraphStage[FanInShape20[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, O]]
ZipWith
specialized for 20 inputs -
class
ZipWith3
[A1, A2, A3, O] extends GraphStage[FanInShape3[A1, A2, A3, O]]
ZipWith
specialized for 3 inputs -
class
ZipWith4
[A1, A2, A3, A4, O] extends GraphStage[FanInShape4[A1, A2, A3, A4, O]]
ZipWith
specialized for 4 inputs -
class
ZipWith5
[A1, A2, A3, A4, A5, O] extends GraphStage[FanInShape5[A1, A2, A3, A4, A5, O]]
ZipWith
specialized for 5 inputs -
class
ZipWith6
[A1, A2, A3, A4, A5, A6, O] extends GraphStage[FanInShape6[A1, A2, A3, A4, A5, A6, O]]
ZipWith
specialized for 6 inputs -
class
ZipWith7
[A1, A2, A3, A4, A5, A6, A7, O] extends GraphStage[FanInShape7[A1, A2, A3, A4, A5, A6, A7, O]]
ZipWith
specialized for 7 inputs -
class
ZipWith8
[A1, A2, A3, A4, A5, A6, A7, A8, O] extends GraphStage[FanInShape8[A1, A2, A3, A4, A5, A6, A7, A8, O]]
ZipWith
specialized for 8 inputs -
class
ZipWith9
[A1, A2, A3, A4, A5, A6, A7, A8, A9, O] extends GraphStage[FanInShape9[A1, A2, A3, A4, A5, A6, A7, A8, A9, O]]
ZipWith
specialized for 9 inputs - trait ZipWithApply extends AnyRef
-
class
ZipWithN
[A, O] extends GraphStage[UniformFanInShape[A, O]]
Combine the elements of multiple streams into a stream of sequences using a combiner function.
Combine the elements of multiple streams into a stream of sequences using a combiner function.
A
ZipWithN
has an
input ports and oneout
portEmits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
Value Members
- object Balance
- object BidiFlow
- object Broadcast
-
object
BroadcastHub
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers. It consissts 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 arbitrary many times, where weach of the new materializations will receive their elements from the original Sink.
- object Compression
- object Concat
-
object
CoupledTerminationFlow
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow them them.
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow them them. Similar to
Flow.fromSinkAndSource
however that API does not connect the completion signals of the wrapped stages. -
object
FileIO
Java API: Factories to create sinks and sources from files
- object Flow
- object Framing
-
object
GraphApply
INTERNAL API
- object GraphDSL extends GraphApply
- object Interleave
-
object
JsonFraming
Provides JSON framing stages that can separate valid JSON objects from incoming ByteString objects.
-
object
Keep
Convenience functions for often-encountered purposes like keeping only the left (first) or only the right (second) of two input values.
- object Merge
-
object
MergeHub
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of producers.
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.
- object MergePreferred
-
object
ModuleExtractor
INTERNAL API
- object OrElse
- object Partition
- object RunnableGraph extends Serializable
- object ScalaSessionAPI
- object Sink
- object Source
-
object
StreamConverters
Converters for interacting with the blocking
java.io
streams APIs and Java 8 Streams -
object
TLS
Stream cipher support based upon JSSE.
Stream cipher support based upon JSSE.
The underlying SSLEngine has four ports: plaintext input/output and ciphertext input/output. These are modeled as a akka.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 Akka 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 SSLContext from which the SSLEngine is then created. Handshake parameters are set using NegotiateNewSession messages, the settings for the initial handshake need to be provided up front using the same class; please refer to the method documentation below.
IMPORTANT NOTE
The TLS specification does 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 stage 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 stage 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 stage will shut down once both events have been received. See also TLSClosing.
-
object
TLSPlacebo
This object holds simple wrapping akka.stream.scaladsl.BidiFlow implementations that can be used instead of TLS when no encryption is desired.
This object holds simple wrapping akka.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.
- object Tcp extends ExtensionId[Tcp] with ExtensionIdProvider
-
object
Unzip
Takes a stream of pair elements and splits each pair to two output streams.
Takes a stream of pair elements and splits each pair to two output streams.
An
Unzip
has onein
port and oneleft
and oneright
output port.Emits when all of the outputs stops backpressuring and there is an input element available
Backpressures when any of the outputs backpressures
Completes when upstream completes
Cancels when any downstream cancels
-
object
UnzipWith
extends UnzipWithApply
Transforms each element of input stream into multiple streams using a splitter function.
Transforms each element of input stream into multiple streams using a splitter function.
Emits when all of the outputs stops backpressuring and there is an input element available
Backpressures when any of the outputs backpressures
Completes when upstream completes
Cancels when any downstream cancels
- object UnzipWithApply
- object Zip
- object ZipN
-
object
ZipWith
extends ZipWithApply
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
Emits when all of the inputs has an element available
Backpressures when downstream backpressures
Completes when any upstream completes
Cancels when downstream cancels
- object ZipWithN