package javadsl
- Alphabetic
- By Inheritance
- javadsl
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
sealed abstract final
class
AsPublisher
extends Enum[AsPublisher]
Copyright (C) 2016 Lightbend Inc.
Copyright (C) 2016 Lightbend Inc. <http://www.lightbend.com>
- final class BidiFlow [-I1, +O1, -I2, +O2, +Mat] extends Graph[BidiShape[I1, O1, I2, O2], Mat]
-
final
class
Flow
[-In, +Out, +Mat] extends Graph[FlowShape[In, Out], Mat]
Create a
Flow
which can process elements of typeT
. -
sealed abstract final
class
FramingTruncation
extends Enum[FramingTruncation]
Determines mode in which Framing operates.
-
abstract
class
RunnableGraph
[+Mat] extends Graph[ClosedShape, Mat]
Java API
Java API
Flow with attached input and output, can be executed.
-
final
class
Sink
[-In, +Mat] extends Graph[SinkShape[In], Mat]
Java API
Java API
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.
-
final
class
Source
[+Out, +Mat] extends Graph[SourceShape[Out], Mat]
Java API
Java API
A
Source
is a set of stream processing steps that has one open output and an attached input. Can be used as aPublisher
-
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.
-
class
SubFlow
[-In, +Out, +Mat] extends AnyRef
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. -
class
SubSource
[+Out, +Mat] extends AnyRef
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. - class Tcp extends Extension
Value Members
- def combinerToScala[M1, M2, M](f: Function2[M1, M2, M]): (M1, M2) ⇒ M
-
object
Balance
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 shutdown until the subscriptions for at least two downstream subscribers have been established.
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
- object BidiFlow
-
object
Broadcast
Fan-out the stream to several streams.
Fan-out the stream to several streams. emitting each incoming upstream element to all downstream consumers. It will not shutdown 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
-
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
Takes two streams and outputs an output stream formed from the two input streams by consuming one stream first emitting all of its elements, then consuming the second stream emitting all of its elements.
Takes two streams and outputs an output stream formed from the two input streams by consuming one stream first emitting all of its elements, then consuming the second stream emitting all of its elements.
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
-
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
Factories to create sinks and sources from files
- object Flow
- object Framing
- object GraphDSL extends GraphCreate
-
object
JsonFraming
Provides JSON framing stages that can separate valid JSON objects from incoming akka.util.ByteString objects.
- object Keep
-
object
Merge
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)
Cancels when downstream cancels
-
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
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).
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)
Cancels when downstream cancels
-
object
Partition
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 all of the outputs stops backpressuring and there is an input element available
Backpressures when one of the outputs backpressure
Completes when upstream completes
Cancels when when one of the downstreams cancel
- object RunnableGraph
-
object
Sink
Java API
-
object
Source
Java API
-
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
Split one stream into several streams using a splitting function.
Split one stream into several streams using a splitting 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
Zip
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
-
object
ZipN
Combine the elements of multiple streams into a stream of lists.
Combine the elements of multiple streams into a stream of lists.
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
-
object
ZipWith
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
Combine the elements of multiple streams into a stream of lists using a combiner function.
Combine the elements of multiple streams into a stream of lists 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