package stream
- Alphabetic
- Public
- All
Type Members
-
final
class
AbruptStageTerminationException extends RuntimeException with NoStackTrace
Signal that the operator was abruptly terminated, usually seen as a call to
postStop
of theGraphStageLogic
without any of the handler callbacks seeing completion or failure from upstream or cancellation from downstream.Signal that the operator was abruptly terminated, usually seen as a call to
postStop
of theGraphStageLogic
without any of the handler callbacks seeing completion or failure from upstream or cancellation from downstream. This can happen when the actor running the graph is killed, which happens when the materializer or actor system is terminated. -
final
case class
AbruptTerminationException(actor: ActorRef) extends RuntimeException with NoStackTrace with Product with Serializable
This exception signals that an actor implementing a Reactive Streams Subscriber, Publisher or Processor has been terminated without being notified by an onError, onComplete or cancel signal.
This exception signals that an actor implementing a Reactive Streams Subscriber, Publisher or Processor has been terminated without being notified by an onError, onComplete or cancel signal. This usually happens when an ActorSystem is shut down while stream processing actors are still running.
-
abstract
class
AbstractShape extends Shape
Java API for creating custom Shape types.
-
final
class
ActorMaterializerSettings extends AnyRef
This class describes the configurable properties of the ActorMaterializer.
This class describes the configurable properties of the ActorMaterializer. Please refer to the
withX
methods for descriptions of the individual settings.The constructor is not public API, use create or apply on the ActorMaterializerSettings companion instead.
- Annotations
- @nowarn()
-
case class
AmorphousShape(inlets: Seq[Inlet[_]], outlets: Seq[Outlet[_]]) extends Shape with Product with Serializable
This type of Shape can express any number of inputs and outputs at the expense of forgetting about their specific types.
-
final
class
Attributes extends Product with Serializable with Equals
Holds attributes which can be used to alter akka.stream.scaladsl.Flow / akka.stream.javadsl.Flow or akka.stream.scaladsl.GraphDSL / akka.stream.javadsl.GraphDSL materialization.
Holds attributes which can be used to alter akka.stream.scaladsl.Flow / akka.stream.javadsl.Flow or akka.stream.scaladsl.GraphDSL / akka.stream.javadsl.GraphDSL materialization.
Note that more attributes for the Materializer are defined in ActorAttributes.
The
is ordered with the most specific attribute first, least specific last. Note that the order was the opposite in Akka 2.4.x.attributeList
Operators should in general not access the
attributeList
but instead useget
to get the expected value of an attribute.Constructor is internal Akka API, use factories in companion to create instances.
- final class BackpressureTimeoutException extends StreamTimeoutException
-
final
case class
BidiShape[-In1, +Out1, -In2, +Out2](in1: Inlet[In1], out1: Outlet[Out1], in2: Inlet[In2], out2: Outlet[Out2]) extends Shape with Product with Serializable
A bidirectional flow of elements that consequently has two inputs and two outputs, arranged like this:
A bidirectional flow of elements that consequently has two inputs and two outputs, arranged like this:
+------+ In1 ~>| |~> Out1 | bidi | Out2 <~| |<~ In2 +------+
- class BindFailedException extends StreamTcpException
-
trait
BoundedSourceQueue[T] extends AnyRef
A queue of the given size that gives immediate feedback whether an element could be enqueued or not.
A queue of the given size that gives immediate feedback whether an element could be enqueued or not.
Not for user extension
- Annotations
- @DoNotInherit()
- final case class BufferOverflowException(msg: String) extends RuntimeException with Product with Serializable
-
sealed abstract
class
Client extends TLSRole
The client is usually the side that consumes the service provided by its interlocutor.
The client is usually the side that consumes the service provided by its interlocutor. The precise interpretation of this role is protocol specific.
-
sealed abstract
class
ClosedShape extends Shape
This Shape is used for graphs that have neither open inputs nor open outputs.
This Shape is used for graphs that have neither open inputs nor open outputs. Only such a Graph can be materialized by a Materializer.
-
sealed
trait
CompletionStrategy extends AnyRef
- Annotations
- @DoNotInherit()
- final class CompletionTimeoutException extends StreamTimeoutException
- class ConnectionException extends StreamTcpException
-
sealed abstract
class
DelayOverflowStrategy extends Serializable
Represents a strategy that decides how to deal with a buffer of time based operator that is full but is about to receive a new element.
Represents a strategy that decides how to deal with a buffer of time based operator that is full but is about to receive a new element.
- Annotations
- @DoNotInherit()
-
sealed abstract
class
EagerClose extends TLSClosing
see TLSClosing
- abstract class FanInShape[+O] extends Shape
- class FanInShape10[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +O] extends FanInShape[O]
- class FanInShape11[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +O] extends FanInShape[O]
- class FanInShape12[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +O] extends FanInShape[O]
- class FanInShape13[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +O] extends FanInShape[O]
- class FanInShape14[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +O] extends FanInShape[O]
- class FanInShape15[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +O] extends FanInShape[O]
- class FanInShape16[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +O] extends FanInShape[O]
- class FanInShape17[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +O] extends FanInShape[O]
- class FanInShape18[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +O] extends FanInShape[O]
- class FanInShape19[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +O] extends FanInShape[O]
- class FanInShape2[-T0, -T1, +O] extends FanInShape[O]
- class FanInShape20[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +O] extends FanInShape[O]
- class FanInShape21[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +O] extends FanInShape[O]
- class FanInShape22[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +O] extends FanInShape[O]
- class FanInShape3[-T0, -T1, -T2, +O] extends FanInShape[O]
- class FanInShape4[-T0, -T1, -T2, -T3, +O] extends FanInShape[O]
- class FanInShape5[-T0, -T1, -T2, -T3, -T4, +O] extends FanInShape[O]
- class FanInShape6[-T0, -T1, -T2, -T3, -T4, -T5, +O] extends FanInShape[O]
- class FanInShape7[-T0, -T1, -T2, -T3, -T4, -T5, -T6, +O] extends FanInShape[O]
- class FanInShape8[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, +O] extends FanInShape[O]
- class FanInShape9[-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +O] extends FanInShape[O]
- abstract class FanOutShape[-I] extends Shape
- class FanOutShape10[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9] extends FanOutShape[I]
- class FanOutShape11[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10] extends FanOutShape[I]
- class FanOutShape12[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11] extends FanOutShape[I]
- class FanOutShape13[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12] extends FanOutShape[I]
- class FanOutShape14[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13] extends FanOutShape[I]
- class FanOutShape15[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14] extends FanOutShape[I]
- class FanOutShape16[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15] extends FanOutShape[I]
- class FanOutShape17[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16] extends FanOutShape[I]
- class FanOutShape18[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16, +O17] extends FanOutShape[I]
- class FanOutShape19[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16, +O17, +O18] extends FanOutShape[I]
- class FanOutShape2[-I, +O0, +O1] extends FanOutShape[I]
- class FanOutShape20[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16, +O17, +O18, +O19] extends FanOutShape[I]
- class FanOutShape21[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16, +O17, +O18, +O19, +O20] extends FanOutShape[I]
- class FanOutShape22[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16, +O17, +O18, +O19, +O20, +O21] extends FanOutShape[I]
- class FanOutShape3[-I, +O0, +O1, +O2] extends FanOutShape[I]
- class FanOutShape4[-I, +O0, +O1, +O2, +O3] extends FanOutShape[I]
- class FanOutShape5[-I, +O0, +O1, +O2, +O3, +O4] extends FanOutShape[I]
- class FanOutShape6[-I, +O0, +O1, +O2, +O3, +O4, +O5] extends FanOutShape[I]
- class FanOutShape7[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6] extends FanOutShape[I]
- class FanOutShape8[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7] extends FanOutShape[I]
- class FanOutShape9[-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8] extends FanOutShape[I]
-
trait
FlowMonitor[+T] extends AnyRef
Used to monitor the state of a stream
Used to monitor the state of a stream
- T
Type of messages passed by the stream
-
final
case class
FlowShape[-I, +O](in: Inlet[I], out: Outlet[O]) extends Shape with Product with Serializable
A Flow Shape has exactly one input and one output, it looks from the outside like a pipe (but it can be a complex topology of streams within of course).
-
trait
Graph[+S <: Shape, +M] extends AnyRef
Not intended to be directly extended by user classes
Not intended to be directly extended by user classes
- See also
-
final
class
IOOperationIncompleteException extends RuntimeException
This exception signals that a stream has been completed or has an error while there was still IO operations in progress
-
final
case class
IOResult(count: Long, status: Try[Done]) extends Product with Serializable
Holds a result of an IO operation.
Holds a result of an IO operation.
- count
Numeric value depending on context, for example IO operations performed or bytes processed.
- status
Status of the result. Can be either akka.Done or an exception.
- Annotations
- @nowarn()
-
final
class
IOSettings extends AnyRef
- Annotations
- @nowarn()
-
sealed abstract
class
IgnoreBoth extends TLSClosing
see TLSClosing
-
sealed abstract
class
IgnoreCancel extends TLSClosing
see TLSClosing
-
sealed abstract
class
IgnoreComplete extends TLSClosing
see TLSClosing
-
sealed abstract
class
InPort extends AnyRef
An input port of a StreamLayout.Module.
An input port of a StreamLayout.Module. This type logically belongs into the impl package but must live here due to how
sealed
works. It is also used in the Java DSL for “classic Inlets” as a work-around for otherwise unreasonable existential types. - final class InitialTimeoutException extends StreamTimeoutException
- final class Inlet[T] extends InPort
-
final
case class
InvalidPartnerActorException(expectedRef: ActorRef, gotRef: ActorRef, msg: String) extends IllegalStateException with Product with Serializable
Stream refs establish a connection between a local and remote actor, representing the origin and remote sides of a stream.
Stream refs establish a connection between a local and remote actor, representing the origin and remote sides of a stream. Each such actor refers to the other side as its "partner". We make sure that no other actor than the initial partner can send demand/messages to the other side accidentally.
This exception is thrown when a message is received from a non-partner actor, which could mean a bug or some actively malicient behavior from the other side.
This is not meant as a security feature, but rather as plain sanity-check.
- final case class InvalidSequenceNumberException(expectedSeqNr: Long, gotSeqNr: Long, msg: String) extends IllegalStateException with Product with Serializable
-
trait
KillSwitch extends AnyRef
A KillSwitch allows completion of Graphs from the outside by completing Graphs of FlowShape linked to the switch.
A KillSwitch allows completion of Graphs from the outside by completing Graphs of FlowShape linked to the switch. Depending on whether the KillSwitch is a UniqueKillSwitch or a SharedKillSwitch one or multiple streams might be linked with the switch. For details see the documentation of the concrete subclasses of this interface.
-
class
MaterializationException extends RuntimeException
This exception or subtypes thereof should be used to signal materialization failures.
-
abstract
class
Materializer extends AnyRef
The Materializer is the component responsible for turning a stream blueprint into a running stream.
The Materializer is the component responsible for turning a stream blueprint into a running stream. In general the system wide materializer should be preferred over creating instances manually.
Not for user extension
- Annotations
- @implicitNotFound( ... ) @nowarn() @DoNotInherit()
-
trait
MaterializerLoggingProvider extends AnyRef
Not for user extension
Not for user extension
- Annotations
- @DoNotInherit()
- final class NeverMaterializedException extends RuntimeException
-
sealed abstract
class
OutPort extends AnyRef
An output port of a StreamLayout.Module.
An output port of a StreamLayout.Module. This type logically belongs into the impl package but must live here due to how
sealed
works. It is also used in the Java DSL for “classic Outlets” as a work-around for otherwise unreasonable existential types. - final class Outlet[T] extends OutPort
-
sealed abstract
class
OverflowStrategy extends DelayOverflowStrategy
Represents a strategy that decides how to deal with a buffer that is full but is about to receive a new element.
Represents a strategy that decides how to deal with a buffer that is full but is about to receive a new element.
- Annotations
- @DoNotInherit()
-
sealed abstract
class
QueueCompletionResult extends QueueOfferResult
Not for user extension
Not for user extension
- Annotations
- @DoNotInherit()
-
sealed abstract
class
QueueOfferResult extends AnyRef
Not for user extension
Not for user extension
- Annotations
- @DoNotInherit()
-
class
RateExceededException extends RuntimeException
Exception that is thrown when rated controlled by stream is exceeded
- final case class RemoteStreamRefActorTerminatedException(msg: String) extends RuntimeException with Product with Serializable
- final class RestartSettings extends AnyRef
-
sealed abstract
class
Server extends TLSRole
The server is usually the side the provides the service to its interlocutor.
The server is usually the side the provides the service to its interlocutor. The precise interpretation of this role is protocol specific.
-
abstract
class
Shape extends AnyRef
A Shape describes the inlets and outlets of a Graph.
A Shape describes the inlets and outlets of a Graph. In keeping with the philosophy that a Graph is a freely reusable blueprint, everything that matters from the outside are the connections that can be made with it, otherwise it is just a black box.
-
final
class
SharedKillSwitch extends KillSwitch
A SharedKillSwitch is a provider for Graphs of FlowShape that can be completed or failed from the outside.
A SharedKillSwitch is a provider for Graphs of FlowShape that can be completed or failed from the outside. A Graph returned by the switch can be materialized arbitrary amount of times: every newly materialized Graph belongs to the switch from which it was acquired. Multiple SharedKillSwitch instances are isolated from each other, shutting down or aborting on instance does not affect the Graphs provided by another instance.
After calling SharedKillSwitch#shutdown all materialized, running instances of all Graphs provided by the SharedKillSwitch will complete their downstreams and cancel their upstreams (unless if finished or failed already in which case the command is ignored). Subsequent invocations of SharedKillSwitch#shutdown and SharedKillSwitch#abort will be ignored.
After calling SharedKillSwitch#abort all materialized, running instances of all Graphs provided by the SharedKillSwitch will fail their downstreams with the provided exception and cancel their upstreams (unless it finished or failed already in which case the command is ignored). Subsequent invocations of SharedKillSwitch#shutdown and SharedKillSwitch#abort will be ignored.
The Graphs provided by the SharedKillSwitch do not modify the passed through elements in any way or affect backpressure in the stream. All provided Graphs provide the parent SharedKillSwitch as materialized value.
This class is thread-safe, the instance can be passed safely among threads and its methods may be invoked concurrently.
-
trait
SinkRef[In] extends AnyRef
A SinkRef allows sharing a "reference" to a Sink with others, with the main purpose of crossing a network boundary.
A SinkRef allows sharing a "reference" to a Sink with others, with the main purpose of crossing a network boundary. Usually obtaining a SinkRef would be done via Actor messaging, in which one system asks a remote one, to accept some data from it, and the remote one decides to accept the request to send data in a back-pressured streaming fashion -- using a sink ref.
To create a SinkRef you have to materialize the
Sink
that you want to obtain a reference to by attaching it to aStreamRefs.sinkRef()
.Stream refs can be seen as Reactive Streams over network boundaries. See also akka.stream.SourceRef which is the dual of a
SinkRef
.For additional configuration see
reference.conf
as well as akka.stream.StreamRefAttributes.Not for user extension.
- Annotations
- @DoNotInherit()
-
final
case class
SinkShape[-T](in: Inlet[T]) extends Shape with Product with Serializable
A Sink Shape has exactly one input and no outputs, it models a data sink.
-
trait
SourceRef[T] extends AnyRef
A SourceRef allows sharing a "reference" with others, with the main purpose of crossing a network boundary.
A SourceRef allows sharing a "reference" with others, with the main purpose of crossing a network boundary. Usually obtaining a SourceRef would be done via Actor messaging, in which one system asks a remote one, to share some data with it, and the remote one decides to do so in a back-pressured streaming fashion -- using a stream ref.
To create a SourceRef you have to materialize the
Source
that you want to obtain a reference to by attaching it to aSink.sourceRef
.Stream refs can be seen as Reactive Streams over network boundaries. See also akka.stream.SinkRef which is the dual of a
SourceRef
.For additional configuration see
reference.conf
as well as akka.stream.StreamRefAttributes.Not for user extension.
- Annotations
- @DoNotInherit()
-
final
case class
SourceShape[+T](out: Outlet[T]) extends Shape with Product with Serializable
A Source Shape has exactly one output and no inputs, it models a source of data.
-
final
class
StreamDetachedException extends RuntimeException with NoStackTrace
This exception signals that materialized value is already detached from stream.
This exception signals that materialized value is already detached from stream. This usually happens when stream is completed and an ActorSystem is shut down while materialized object is still available.
- final class StreamIdleTimeoutException extends StreamTimeoutException
- class StreamLimitReachedException extends RuntimeException
- final class StreamRefMessages extends AnyRef
-
trait
StreamRefResolver extends Extension
The stream ref resolver provides a way to serialize and deserialize streamrefs in user serializers.
The stream ref resolver provides a way to serialize and deserialize streamrefs in user serializers.
Not for user extension
- Annotations
- @DoNotInherit()
- trait StreamRefSettings extends AnyRef
- final case class StreamRefSubscriptionTimeoutException(msg: String) extends IllegalStateException with Product with Serializable
-
final
class
StreamSubscriptionTimeoutSettings extends AnyRef
Leaked publishers and subscribers are cleaned up when they are not used within a given deadline, configured by StreamSubscriptionTimeoutSettings.
Leaked publishers and subscribers are cleaned up when they are not used within a given deadline, configured by StreamSubscriptionTimeoutSettings.
- Annotations
- @nowarn()
-
sealed abstract
class
StreamSubscriptionTimeoutTerminationMode extends AnyRef
This mode describes what shall happen when the subscription timeout expires for substream Publishers created by operations like
prefixAndTail
. - class StreamTcpException extends RuntimeException with NoStackTrace
-
sealed
class
StreamTimeoutException extends TimeoutException with NoStackTrace
Base class for timeout exceptions specific to Akka Streams
Base class for timeout exceptions specific to Akka Streams
Not for user extension
- Annotations
- @DoNotInherit()
-
trait
SubscriptionWithCancelException extends Subscription
Extension of Subscription that allows to pass a cause when a subscription is cancelled.
Extension of Subscription that allows to pass a cause when a subscription is cancelled.
Subscribers can check for this trait and use its
cancel(cause)
method instead of the regular cancel method to pass a cancellation cause.Not for user extension.
- Annotations
- @DoNotInherit()
-
sealed abstract
class
SubstreamCancelStrategy extends AnyRef
Represents a strategy that decides how to deal with substream events.
- final class SystemMaterializer extends Extension
-
sealed abstract
class
TLSClientAuth extends AnyRef
An SSLEngine can either demand, allow or ignore its peer’s authentication (via certificates), where
Need
will fail the handshake if the peer does not provide valid credentials,Want
allows the peer to send credentials and verifies them if provided, andNone
disables peer certificate verification.An SSLEngine can either demand, allow or ignore its peer’s authentication (via certificates), where
Need
will fail the handshake if the peer does not provide valid credentials,Want
allows the peer to send credentials and verifies them if provided, andNone
disables peer certificate verification.See the documentation for
SSLEngine::setWantClientAuth
for more information. -
sealed abstract
class
TLSClosing extends AnyRef
All streams in Akka are unidirectional: while in a complex flow graph data may flow in multiple directions these individual flows are independent from each other.
All streams in Akka are unidirectional: while in a complex flow graph data may flow in multiple directions these individual flows are independent from each other. The difference between two half-duplex connections in opposite directions and a full-duplex connection is that the underlying transport is shared in the latter and tearing it down will end the data transfer in both directions.
When integrating a full-duplex transport medium that does not support half-closing (which means ending one direction of data transfer without ending the other) into a stream topology, there can be unexpected effects. Feeding a finite Source into this medium will close the connection after all elements have been sent, which means that possible replies may not be received in full. To support this type of usage, the sending and receiving of data on the same side (e.g. on the Client) need to be coordinated such that it is known when all replies have been received. Only then should the transport be shut down.
To support these scenarios it is recommended that the full-duplex transport integration is configurable in terms of termination handling, which means that the user can optionally suppress the normal (closing) reaction to completion or cancellation events, as is expressed by the possible values of this type:
- EagerClose means to not ignore signals
- IgnoreCancel means to not react to cancellation of the receiving side unless the sending side has already completed
- IgnoreComplete means to not react to the completion of the sending side unless the receiving side has already canceled
- IgnoreBoth means to ignore the first termination signal—be that cancellation or completion—and only act upon the second one
- sealed abstract class TLSRole extends AnyRef
- final case class TargetRefNotInitializedYetException() extends IllegalStateException with Product with Serializable
-
sealed abstract
class
ThrottleMode extends AnyRef
Represents a mode that decides how to deal exceed rate for Throttle operator
-
final
class
TooManySubstreamsOpenException extends IllegalStateException with NoStackTrace
This exception signals that the maximum number of substreams declared has been exceeded.
This exception signals that the maximum number of substreams declared has been exceeded. A finite limit is imposed so that memory usage is controlled.
- class UniformFanInShape[-T, +O] extends FanInShape[O]
- class UniformFanOutShape[-I, +O] extends FanOutShape[I]
-
final
class
UniqueKillSwitch extends KillSwitch
A UniqueKillSwitch is always a result of a materialization (unlike SharedKillSwitch which is constructed before any materialization) and it always controls that graph and operator which yielded the materialized value.
A UniqueKillSwitch is always a result of a materialization (unlike SharedKillSwitch which is constructed before any materialization) and it always controls that graph and operator which yielded the materialized value.
After calling UniqueKillSwitch#shutdown the running instance of the Graph of FlowShape that materialized to the UniqueKillSwitch will complete its downstream and cancel its upstream (unless if finished or failed already in which case the command is ignored). Subsequent invocations of completion commands will be ignored.
After calling UniqueKillSwitch#abort the running instance of the Graph of FlowShape that materialized to the UniqueKillSwitch will fail its downstream with the provided exception and cancel its upstream (unless if finished or failed already in which case the command is ignored). Subsequent invocations of completion commands will be ignored.
It is also possible to individually cancel, complete or fail upstream and downstream parts by calling the corresponding methods.
-
final
class
WatchedActorTerminatedException extends RuntimeException
Used as failure exception by an
ask
operator if the target actor terminates.Used as failure exception by an
ask
operator if the target actor terminates. SeeFlow.ask
andFlow.watch
. -
final
case class
AbruptIOTerminationException(ioResult: IOResult, cause: Throwable) extends RuntimeException with NoStackTrace with Product with Serializable
This exception signals that a stream has been completed by an onError signal while there was still IO operations in progress.
This exception signals that a stream has been completed by an onError signal while there was still IO operations in progress.
- Annotations
- @deprecated @nowarn()
- Deprecated
(Since version 2.6.0) use IOOperationIncompleteException
-
abstract
class
ActorMaterializer extends Materializer with MaterializerLoggingProvider
An ActorMaterializer takes a stream blueprint and turns it into a running stream.
An ActorMaterializer takes a stream blueprint and turns it into a running stream.
- Annotations
- @deprecated
- Deprecated
(Since version 2.6.0) The Materializer now has all methods the ActorMaterializer used to have
Value Members
-
object
ActorAttributes
Attributes for the Materializer.
Attributes for the Materializer. Note that more attributes defined in Attributes.
- object ActorMaterializer
- object ActorMaterializerSettings
-
object
Attributes extends Serializable
Note that more attributes for the Materializer are defined in ActorAttributes.
- object BidiShape extends Serializable
- object Client extends Client with Product with Serializable
- object ClosedShape extends ClosedShape
- object CompletionStrategy extends Product with Serializable
- object DelayOverflowStrategy extends Serializable
- object EagerClose extends EagerClose with Product with Serializable
- object FanInShape
- object FanOutShape
- object FlowMonitorState
- object FlowShape extends Serializable
- object Graph
- object IOResult extends Serializable
- object IOSettings
- object IgnoreBoth extends IgnoreBoth with Product with Serializable
- object IgnoreCancel extends IgnoreCancel with Product with Serializable
- object IgnoreComplete extends IgnoreComplete with Product with Serializable
-
object
Inlet
An Inlet is a typed input to a Shape.
An Inlet is a typed input to a Shape. Its partner in the Module view is the InPort (which does not bear an element type because Modules only express the internal structural hierarchy of stream topologies).
-
object
KillSwitches
Creates shared or single kill switches which can be used to control completion of graphs from the outside.
Creates shared or single kill switches which can be used to control completion of graphs from the outside.
- The factory
returns a SharedKillSwitch which provides a Graph of FlowShape that can be used in arbitrary number of graphs and materializations. The switch simultaneously controls completion in all of those graphs.shared()
- The factory
returns a Graph of FlowShape that materializes to a UniqueKillSwitch which is always unique to that materialized Flow itself.single()
Creates a SharedKillSwitch that can be used to externally control the completion of various streams.
- The factory
- object Materializer
-
object
Outlet
An Outlet is a typed output to a Shape.
An Outlet is a typed output to a Shape. Its partner in the Module view is the OutPort (which does not bear an element type because Modules only express the internal structural hierarchy of stream topologies).
- object OverflowStrategy extends Serializable
-
object
QueueOfferResult
Contains types that is used as return types for streams Source queues
- object RestartSettings
- object Server extends Server with Product with Serializable
-
object
SinkRef
See full documentation on SinkRef.
- object SinkShape extends Serializable
-
object
SourceRef
See full documentation on SourceRef.
- object SourceShape extends Serializable
-
object
StreamRefAttributes
Attributes for stream refs (akka.stream.SourceRef and akka.stream.SinkRef).
Attributes for stream refs (akka.stream.SourceRef and akka.stream.SinkRef). Note that more attributes defined in Attributes and ActorAttributes.
-
object
StreamRefResolver extends ExtensionId[StreamRefResolver]
The stream ref resolver extension provides a way to serialize and deserialize streamrefs in user serializers.
-
object
StreamRefSettings
- Annotations
- @nowarn()
- object StreamSubscriptionTimeoutSettings
- object StreamSubscriptionTimeoutTerminationMode
- object SubscriptionWithCancelException
- object SubstreamCancelStrategy
- object Supervision
-
object
SystemMaterializer extends ExtensionId[SystemMaterializer] with ExtensionIdProvider
The system materializer is a default materializer to use for most cases running streams, it is a single instance per actor system that is tied to the lifecycle of that system.
The system materializer is a default materializer to use for most cases running streams, it is a single instance per actor system that is tied to the lifecycle of that system.
Not intended to be manually used in user code.
- object TLSClientAuth
- object TLSClosing
- object TLSProtocol
-
object
TLSRole
Many protocols are asymmetric and distinguish between the client and the server, where the latter listens passively for messages and the former actively initiates the exchange.
- object ThrottleMode
- object UniformFanInShape
- object UniformFanOutShape
Deprecated Value Members
-
object
BindFailedException extends BindFailedException with Product with Serializable
- Annotations
- @deprecated
- Deprecated
(Since version 2.4.19) BindFailedException object will never be thrown. Match on the class instead.