Packages

p

akka

stream

package stream

Content Hierarchy
UniqueKillSwitchUniformFanOutShape[I, O]UniformFanInShape[T, O]TLSRoleServerClientTLSClosingIgnoreCompleteIgnoreCancelIgnoreBothEagerCloseStreamTcpExceptionConnectionExceptionBindFailedExceptionSourceShape[T]SinkShape[T]SharedKillSwitchShapeFlowShape[I, O]FanOutShape[I]FanInShape[O]ClosedShapeBidiShape[In1, Out1, In2, Out2]AmorphousShapeAbstractShapeServerOverflowStrategyOutlet[T]OutPortMaterializerLoggingProviderActorMaterializerMaterializerKillSwitchInlet[T]InPortIgnoreCompleteIgnoreCancelIgnoreBothFanOutShape9[I, O0, O1, O2, O3, O4, O5, O6, O7, O8]FanOutShape8[I, O0, O1, O2, O3, O4, O5, O6, O7]FanOutShape7[I, O0, O1, O2, O3, O4, O5, O6]FanOutShape6[I, O0, O1, O2, O3, O4, O5]FanOutShape5[I, O0, O1, O2, O3, O4]FanOutShape4[I, O0, O1, O2, O3]FanOutShape3[I, O0, O1, O2]FanOutShape22[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21]FanOutShape21[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20]FanOutShape20[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19]FanOutShape2[I, O0, O1]FanOutShape19[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18]FanOutShape18[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17]FanOutShape17[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16]FanOutShape16[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15]FanOutShape15[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14]FanOutShape14[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13]FanOutShape13[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12]FanOutShape12[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11]FanOutShape11[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10]FanOutShape10[I, O0, O1, O2, O3, O4, O5, O6, O7, O8, O9]FanInShape9[T0, T1, T2, T3, T4, T5, T6, T7, T8, O]FanInShape8[T0, T1, T2, T3, T4, T5, T6, T7, O]FanInShape7[T0, T1, T2, T3, T4, T5, T6, O]FanInShape6[T0, T1, T2, T3, T4, T5, O]FanInShape5[T0, T1, T2, T3, T4, O]FanInShape4[T0, T1, T2, T3, O]FanInShape3[T0, T1, T2, O]FanInShape22[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, O]FanInShape21[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, O]FanInShape20[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, O]FanInShape2[T0, T1, O]FanInShape1N[T0, T1, O]FanInShape19[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, O]FanInShape18[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, O]FanInShape17[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, O]FanInShape16[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, O]FanInShape15[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, O]FanInShape14[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, O]FanInShape13[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, O]FanInShape12[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, O]FanInShape11[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, O]FanInShape10[T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, O]EagerCloseDelayOverflowStrategyClosedShapeClientBindFailedException
Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. final class AbruptStageTerminationException extends RuntimeException with NoStackTrace

    Signal that the stage was abruptly terminated, usually seen as a call to postStop of the GraphStageLogic without any of the handler callbacks seeing completion or failure from upstream or cancellation from downstream.

    Signal that the stage was abruptly terminated, usually seen as a call to postStop of the GraphStageLogic 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.

  2. 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.

  3. abstract class AbstractShape extends Shape

    Java API for creating custom Shape types.

  4. abstract class ActorMaterializer extends Materializer with MaterializerLoggingProvider

    An ActorMaterializer takes the list of transformations comprising a akka.stream.scaladsl.Flow and materializes them in the form of org.reactivestreams.Processor instances.

    An ActorMaterializer takes the list of transformations comprising a akka.stream.scaladsl.Flow and materializes them in the form of org.reactivestreams.Processor instances. How transformation steps are split up into asynchronous regions is implementation dependent.

  5. 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.

  6. 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.

    This type of Shape can express any number of inputs and outputs at the expense of forgetting about their specific types. It is used mainly in the implementation of the Graph builders and typically replaced by a more meaningful type of Shape when the building is finished.

  7. final case class Attributes (attributeList: List[Attribute] = Nil) extends Product with Serializable

    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 ActorMaterializer are defined in ActorAttributes.

  8. 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
       +------+
  9. class BindFailedException extends StreamTcpException
  10. final case class BufferOverflowException (msg: String) extends RuntimeException with Product with Serializable
  11. 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.

  12. 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.

  13. class ConnectionException extends StreamTcpException
  14. sealed abstract class DelayOverflowStrategy extends Serializable

    Represents a strategy that decides how to deal with a buffer of time based stage that is full but is about to receive a new element.

  15. sealed abstract class EagerClose extends TLSClosing

    see TLSClosing

  16. abstract class FanInShape [+O] extends Shape
  17. class FanInShape10 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +O] extends FanInShape[O]
  18. class FanInShape11 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +O] extends FanInShape[O]
  19. class FanInShape12 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +O] extends FanInShape[O]
  20. class FanInShape13 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +O] extends FanInShape[O]
  21. class FanInShape14 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +O] extends FanInShape[O]
  22. class FanInShape15 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +O] extends FanInShape[O]
  23. class FanInShape16 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +O] extends FanInShape[O]
  24. class FanInShape17 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +O] extends FanInShape[O]
  25. class FanInShape18 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +O] extends FanInShape[O]
  26. 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]
  27. class FanInShape1N [-T0, -T1, +O] extends FanInShape[O]
  28. class FanInShape2 [-T0, -T1, +O] extends FanInShape[O]
  29. 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]
  30. 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]
  31. 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]
  32. class FanInShape3 [-T0, -T1, -T2, +O] extends FanInShape[O]
  33. class FanInShape4 [-T0, -T1, -T2, -T3, +O] extends FanInShape[O]
  34. class FanInShape5 [-T0, -T1, -T2, -T3, -T4, +O] extends FanInShape[O]
  35. class FanInShape6 [-T0, -T1, -T2, -T3, -T4, -T5, +O] extends FanInShape[O]
  36. class FanInShape7 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, +O] extends FanInShape[O]
  37. class FanInShape8 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, +O] extends FanInShape[O]
  38. class FanInShape9 [-T0, -T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +O] extends FanInShape[O]
  39. abstract class FanOutShape [-I] extends Shape
  40. class FanOutShape10 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9] extends FanOutShape[I]
  41. class FanOutShape11 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10] extends FanOutShape[I]
  42. class FanOutShape12 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11] extends FanOutShape[I]
  43. class FanOutShape13 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12] extends FanOutShape[I]
  44. class FanOutShape14 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13] extends FanOutShape[I]
  45. class FanOutShape15 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14] extends FanOutShape[I]
  46. class FanOutShape16 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15] extends FanOutShape[I]
  47. class FanOutShape17 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16] extends FanOutShape[I]
  48. class FanOutShape18 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8, +O9, +O10, +O11, +O12, +O13, +O14, +O15, +O16, +O17] extends FanOutShape[I]
  49. 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]
  50. class FanOutShape2 [-I, +O0, +O1] extends FanOutShape[I]
  51. 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]
  52. 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]
  53. 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]
  54. class FanOutShape3 [-I, +O0, +O1, +O2] extends FanOutShape[I]
  55. class FanOutShape4 [-I, +O0, +O1, +O2, +O3] extends FanOutShape[I]
  56. class FanOutShape5 [-I, +O0, +O1, +O2, +O3, +O4] extends FanOutShape[I]
  57. class FanOutShape6 [-I, +O0, +O1, +O2, +O3, +O4, +O5] extends FanOutShape[I]
  58. class FanOutShape7 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6] extends FanOutShape[I]
  59. class FanOutShape8 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7] extends FanOutShape[I]
  60. class FanOutShape9 [-I, +O0, +O1, +O2, +O3, +O4, +O5, +O6, +O7, +O8] extends FanOutShape[I]
  61. 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

  62. 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).

  63. trait Graph [+S <: Shape, +M] extends AnyRef
  64. 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.

  65. sealed abstract class IgnoreBoth extends TLSClosing

    see TLSClosing

  66. sealed abstract class IgnoreCancel extends TLSClosing

    see TLSClosing

  67. sealed abstract class IgnoreComplete extends TLSClosing

    see TLSClosing

  68. 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 “untyped Inlets” as a work-around for otherwise unreasonable existential types.

  69. final class Inlet [T] extends InPort
  70. 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.

  71. case class MaterializationContext (materializer: Materializer, effectiveAttributes: Attributes, stageName: String) extends Product with Serializable

    Context parameter to the create methods of sources and sinks.

  72. class MaterializationException extends RuntimeException

    This exception or subtypes thereof should be used to signal materialization failures.

  73. abstract class Materializer extends AnyRef

    Materializer SPI (Service Provider Interface)

    Materializer SPI (Service Provider Interface)

    Binary compatibility is NOT guaranteed on materializer internals.

    Custom materializer implementations should be aware that the materializer SPI is not yet final and may change in patch releases of Akka. Please note that this does not impact end-users of Akka streams, only implementors of custom materializers, with whom the Akka team co-ordinates such changes.

    Once the SPI is final this notice will be removed.

  74. trait MaterializerLoggingProvider extends AnyRef

    SPI intended only to be extended by custom Materializer implementations, that also want to provide stages they materialize with specialized akka.event.LoggingAdapter instances.

  75. 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 “untyped Outlets” as a work-around for otherwise unreasonable existential types.

  76. final class Outlet [T] extends OutPort
  77. 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.

  78. sealed abstract class QueueOfferResult extends AnyRef
  79. class RateExceededException extends RuntimeException

    Exception that is thrown when rated controlled by stream is exceeded

  80. 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.

  81. 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.

  82. 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.

  83. 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.

  84. 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.

  85. class StreamLimitReachedException extends RuntimeException
  86. final class StreamSubscriptionTimeoutSettings extends AnyRef

    Leaked publishers and subscribers are cleaned up when they are not used within a given deadline, configured by StreamSubscriptionTimeoutSettings.

  87. 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.

  88. class StreamTcpException extends RuntimeException with NoStackTrace
  89. sealed abstract class SubstreamCancelStrategy extends AnyRef

    Represents a strategy that decides how to deal with substream events.

  90. 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, and None 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, and None disables peer certificate verification.

    See the documentation for SSLEngine::setWantClientAuth for more information.

  91. 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
  92. sealed abstract class TLSRole extends AnyRef
  93. sealed abstract class ThrottleMode extends AnyRef

    Represents a mode that decides how to deal exceed rate for Throttle combinator

  94. class UniformFanInShape [-T, +O] extends FanInShape[O]
  95. class UniformFanOutShape [-I, +O] extends FanOutShape[I]
  96. 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 stage 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 stage 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.

Value Members

  1. object ActorAttributes

    Attributes for the ActorMaterializer.

    Attributes for the ActorMaterializer. Note that more attributes defined in Attributes.

  2. object ActorMaterializer
  3. object ActorMaterializerSettings
  4. object Attributes extends Serializable

    Note that more attributes for the ActorMaterializer are defined in ActorAttributes.

  5. object BidiShape extends Serializable
  6. object Client extends Client with Product with Serializable
  7. object ClosedShape extends ClosedShape
  8. object DelayOverflowStrategy extends Serializable
  9. object EagerClose extends EagerClose with Product with Serializable
  10. object FanInShape
  11. object FanOutShape
  12. object FlowMonitorState
  13. object FlowShape extends Serializable
  14. object Fusing

    This class holds some graph transformation functions that can fuse together multiple operation stages into synchronous execution islands.

    This class holds some graph transformation functions that can fuse together multiple operation stages into synchronous execution islands. The purpose is to reduce the number of Actors that are created in order to execute the stream and thereby improve start-up cost as well as reduce element traversal latency for large graphs. Fusing itself is a time-consuming operation, meaning that usually it is best to cache the result of this computation and reuse it instead of fusing the same graph many times.

    Fusing together all operations which allow this treatment will reduce the parallelism that is available in the stream graph’s execution—in the worst case it will become single-threaded and not benefit from multiple CPU cores at all. Where parallelism is required, the akka.stream.Attributes#AsyncBoundary attribute can be used to declare subgraph boundaries across which the graph shall not be fused.

  15. object IOResult extends Serializable
  16. object IgnoreBoth extends IgnoreBoth with Product with Serializable
  17. object IgnoreCancel extends IgnoreCancel with Product with Serializable
  18. object IgnoreComplete extends IgnoreComplete with Product with Serializable
  19. 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).

  20. 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 shared() 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.
    • The factory single() returns a Graph of FlowShape that materializes to a UniqueKillSwitch which is always unique to that materialized Flow itself.

    Creates a SharedKillSwitch that can be used to externally control the completion of various streams.

  21. 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).

  22. object OverflowStrategy extends Serializable
  23. object QueueOfferResult

    Contains types that is used as return types for async callbacks to streams

  24. object Server extends Server with Product with Serializable
  25. object SinkShape extends Serializable
  26. object SourceShape extends Serializable
  27. object StreamSubscriptionTimeoutSettings
  28. object StreamSubscriptionTimeoutTerminationMode
  29. object SubstreamCancelStrategy
  30. object Supervision
  31. object TLSClientAuth
  32. object TLSClosing
  33. object TLSProtocol
  34. 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.

  35. object ThrottleMode
  36. object UniformFanInShape
  37. object UniformFanOutShape

Deprecated Value Members

  1. object BindFailedException extends BindFailedException with Product with Serializable
    Annotations
    @deprecated
    Deprecated

    BindFailedException object will never be thrown. Match on the class instead.

Ungrouped