Packages

  • package root
    Definition Classes
    root
  • package akka
    Definition Classes
    root
  • package stream
    Definition Classes
    akka
  • package actor
    Definition Classes
    stream
  • package extra
    Definition Classes
    stream
  • package javadsl
    Definition Classes
    stream
  • package scaladsl

    Scala API: The flow DSL allows the formulation of stream transformations based on some input.

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

    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.

    Definition Classes
    stream
  • package stage
    Definition Classes
    stream
  • AbstractGraphStageWithMaterializedValue
  • AbstractInHandler
  • AbstractInOutHandler
  • AbstractOutHandler
  • AsyncCallback
  • GraphStage
  • GraphStageLogic
  • GraphStageLogicWithLogging
  • GraphStageWithMaterializedValue
  • InHandler
  • OutHandler
  • StageLogging
  • TimerGraphStageLogic
  • TimerGraphStageLogicWithLogging
  • package testkit
    Definition Classes
    stream
  • package typed
    Definition Classes
    stream
p

akka.stream

stage

package stage

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. abstract class AbstractGraphStageWithMaterializedValue[+S <: Shape, M] extends GraphStageWithMaterializedValue[S, M]

    Java API: A GraphStage represents a reusable graph stream processing operator.

    Java API: A GraphStage represents a reusable graph stream processing operator.

    Extend this AbstractGraphStageWithMaterializedValue if you want to provide a materialized value, represented by the type parameter M. If your GraphStage does not need to provide a materialized value you can instead extende GraphStage which materializes a NotUsed value.

    A GraphStage consists of a Shape which describes its input and output ports and a factory function that creates a GraphStageLogic which implements the processing logic that ties the ports together.

    See also GraphStageWithMaterializedValue for Scala DSL for this operator.

  2. abstract class AbstractInHandler extends InHandler

    Java API: callbacks for an input port where termination logic is predefined (completing when upstream completes, failing when upstream fails).

  3. abstract class AbstractInOutHandler extends InHandler with OutHandler

    Java API: callback combination for output and input ports where termination logic is predefined (completing when upstream completes, failing when upstream fails, completing when downstream cancels).

  4. abstract class AbstractOutHandler extends OutHandler

    Java API: callbacks for an output port where termination logic is predefined (completing when downstream cancels).

  5. trait AsyncCallback[T] extends AnyRef

    An asynchronous callback holder that is attached to a GraphStageLogic.

    An asynchronous callback holder that is attached to a GraphStageLogic. Initializing AsyncCallback#invoke will eventually lead to the registered handler being called.

    This holder has the same lifecycle as a stream and cannot be used before materialization is done.

    Typical use cases are exchanging messages between stream and substreams or invoking from external world sending event to a stream

  6. abstract class GraphStage[S <: Shape] extends GraphStageWithMaterializedValue[S, NotUsed]

    A GraphStage represents a reusable graph stream processing operator.

    A GraphStage represents a reusable graph stream processing operator.

    A GraphStage consists of a Shape which describes its input and output ports and a factory function that creates a GraphStageLogic which implements the processing logic that ties the ports together.

  7. abstract class GraphStageLogic extends AnyRef

    Represents the processing logic behind a GraphStage.

    Represents the processing logic behind a GraphStage. Roughly speaking, a subclass of GraphStageLogic is a collection of the following parts: * A set of InHandler and OutHandler instances and their assignments to the Inlets and Outlets of the enclosing GraphStage * Possible mutable state, accessible from the InHandler and OutHandler callbacks, but not from anywhere else (as such access would not be thread-safe) * The lifecycle hooks preStart() and postStop() * Methods for performing stream processing actions, like pulling or pushing elements

    The operator logic is completed once all its input and output ports have been closed. This can be changed by setting setKeepGoing to true.

    The postStop lifecycle hook on the logic itself is called once all ports are closed. This is the only tear down callback that is guaranteed to happen, if the actor system or the materializer is terminated the handlers may never see any callbacks to onUpstreamFailure, onUpstreamFinish or onDownstreamFinish. Therefore operator resource cleanup should always be done in postStop.

  8. abstract class GraphStageLogicWithLogging extends GraphStageLogic with StageLogging

    Java API: GraphStageLogic with StageLogging.

  9. abstract class GraphStageWithMaterializedValue[+S <: Shape, +M] extends Graph[S, M]

    Scala API: A GraphStage represents a reusable graph stream processing operator.

    Scala API: A GraphStage represents a reusable graph stream processing operator.

    Extend this GraphStageWithMaterializedValue if you want to provide a materialized value, represented by the type parameter M. If your GraphStage does not need to provide a materialized value you can instead extende GraphStage which materializes a NotUsed value.

    A GraphStage consists of a Shape which describes its input and output ports and a factory function that creates a GraphStageLogic which implements the processing logic that ties the ports together.

    See also AbstractGraphStageWithMaterializedValue for Java DSL for this operator.

  10. trait InHandler extends AnyRef

    Collection of callbacks for an input port of a GraphStage

  11. trait OutHandler extends AnyRef

    Collection of callbacks for an output port of a GraphStage

  12. trait StageLogging extends AnyRef

    Simple way to obtain a LoggingAdapter when used together with an ActorMaterializer.

    Simple way to obtain a LoggingAdapter when used together with an ActorMaterializer. If used with a different materializer NoLogging will be returned.

    Make sure to only access log from GraphStage callbacks (such as pull, push or the async-callback).

    Note, abiding to akka.stream.ActorAttributes.logLevels has to be done manually, the logger itself is configured based on the logSource provided to it. Also, the log itself would not know if you're calling it from a "on element" context or not, which is why these decisions have to be handled by the operator itself.

  13. abstract class TimerGraphStageLogic extends GraphStageLogic
  14. abstract class TimerGraphStageLogicWithLogging extends TimerGraphStageLogic with StageLogging

    Java API: TimerGraphStageLogic with StageLogging.

Value Members

  1. object GraphStageLogic

Ungrouped