Namespace Akka.Streams.Dsl

Classes

AccumulateWhileUnchanged<TElement, TProperty>

Accumulates elements of type TElement while extracted property of type TProperty remains unchanged, emits an accumulated sequence when the property changes

Balance<T>

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<T> has one In port and 2 or more Out(Int32) 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

BidiFlow

TBD

BidiFlow<TIn1, TOut1, TIn2, TOut2, TMat>

TBD

Broadcast<T>

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

BroadcastHub

A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers. It consists of two parts, a Sink<TIn, TMat> and a Source<TOut, TMat>. The Sink<TIn, TMat> broadcasts elements from a producer to the actually live consumers it has. Once the producer has been materialized, the Sink<TIn, TMat> it feeds into returns a materialized value which is the corresponding Source<TOut, TMat>. This Source<TOut, TMat> can be materialized arbitrary many times, where each of the new materializations will receive their elements from the original Sink<TIn, TMat>.

ChannelSink

ChannelSource

Container class for Akka.Streams Source<TOut, TMat> factory methods, which can be used to create sources from readable channels.

Concat

TBD

Concat<TIn, TOut>

Takes two streams and outputs one stream formed from the two input streams by first emitting all of the elements from the first stream and then emitting all of the elements from the second stream.

A Concat<TIn, TOut> has one multiple In(Int32) ports and one Out 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

DelayFlow<T>

Flow stage for universal delay management, allows to manage delay through IDelayStrategy<T>.

FileIO

TBD

FixedDelay<T>

Fixed delay strategy, always returns constant delay for any element.

Flow

A Flow is a set of stream processing steps that has one open input and one open output.

Flow<TIn, TOut, TMat>

A Flow<TIn, TOut, TMat> is a set of stream processing steps that has one open input and one open output.

FlowOperations

The set of DSL methods for composing Flow<TIn, TOut, TMat> stages together.

FlowWithContext

FlowWithContext<TIn, TCtxIn, TOut, TCtxOut, TMat>

A flow that provides operations which automatically propagate the context of an element. Only a subset of common operations from Flow is supported. As an escape hatch you can use [[FlowWithContextOps.via]] to manually provide the context propagation for otherwise unsupported operations.

An "empty" flow can be created by calling Create<TIn, TCtx>().

FlowWithContextOperations

ForwardOps

TBD

Framing

TBD

Framing.FramingException

TBD

GraphDsl

A graph DSL, which defines an API for building complex graphs. Graph definitions are enclosed within a scope of functions defined by user, using a dedicated GraphDsl.Builder<T> helper to connect specific graph stages with each other.

GraphDsl.Builder<T>

TBD

GraphDsl.ForwardOps<TOut, TMat>

TBD

GraphDsl.ReverseOps<TIn, TMat>

TBD

Interleave

TBD

Interleave<TIn, TOut>

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 (eagerComplete=false) or one upstream completes (eagerComplete=true)

Cancels when downstream cancels

IntervalBasedRateLimiter

JsonFraming

Provides JSON framing stages that can separate valid JSON objects from incoming ByteString objects.

Keep

Convenience functions for often-encountered purposes like keeping only the left (first) or only the right (second) of two input values.

KeepAliveConcat<T>

Sends elements from buffer if upstream does not emit for a configured amount of time. In other words, this stage attempts to maintains a base rate of emitted elements towards the downstream using elements from upstream.

If upstream emits new elements until the accumulated elements in the buffer exceed the specified minimum size used as the keep alive elements, then the base rate is no longer maintained until we reach another period without elements form upstream.

The keep alive period is the keep alive failover size times the interval.

Emits when upstream emits an element or if the upstream was idle for the configured period

Backpressures when downstream backpressures

Completes when upstream completes

Cancels when downstream cancels

LastElement<T>

This stage materializes to the last element pushed before upstream completion, if any, thereby recovering from any failure. Pushed elements are just passed along.

LinearIncreasingDelay<T>

Strategy with linear increasing delay.

Merge<T>

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

Cancels when downstream cancels

Merge<TIn, TOut>

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

Cancels when downstream cancels

MergeHub

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<TOut, TMat> and a Sink<TIn, TMat>. The Source<TOut, TMat> streams the element to a consumer from its merged inputs. Once the consumer has been materialized, the Source<TOut, TMat> returns a materialized value which is the corresponding Sink<TIn, TMat>. This Sink<TIn, TMat> can then be materialized arbitrary many times, where each of the new materializations will feed its consumed elements to the original Source<TOut, TMat>.

MergeHub.ProducerFailed

TBD

MergePreferred<T>

Merge several streams, taking elements as they arrive from input streams (picking from preferred when several have elements ready).

A MergePreferred<T> has one Out port, one Preferred input port and 0 or more secondary In(Int32) 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)

Cancels when downstream cancels

MergePreferred<T>.MergePreferredShape

TBD

MergePrioritized<T>

Merge several streams, taking elements as they arrive from input streams (picking from prioritized once when several have elements ready). A MergePrioritized<T> has one Out port, one or more input port with their priorities.

Emits when one of the inputs has an element available, preferring a input based on its priority 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

MergeSorted<T>

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

One2OneBidi<TIn, TOut>

TBD

One2OneBidiFlow

TBD

OrElse

TBD

OrElse<T>

Takes two streams and passes the first through, the secondary stream is only passed through if the primary stream completes without passing any elements through. When the first element is passed through from the primary the secondary is cancelled. Both incoming streams are materialized when the stage is materialized.

On errors the stage is failed regardless of source of the error.

'''Emits when''' element is available from primary stream or the primary stream closed without emitting any elements and an element is available from the secondary stream

'''Backpressures when''' downstream backpressures

'''Completes when''' the primary stream completes after emitting at least one element, when the primary stream completes without emitting and the secondary stream already has completed or when the secondary stream completes

'''Cancels when''' downstream cancels

OutputTruncationException

TBD

PagedSource

PagedSource.Page<T, TKey>

Page for PagedSource.

Partition<T>

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

PartitionHub

A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers. It consists of two parts, a Sink<TIn, TMat> and a Source<TOut, TMat>. The Sink<TIn, TMat> e elements from a producer to the actually live consumers it has.The selection of consumer is done with a function. Each element can be routed to only one consumer.Once the producer has been materialized, the Sink<TIn, TMat> it feeds into returns a materialized value which is the corresponding Source<TOut, TMat>. This Source<TOut, TMat> can be materialized an arbitrary number of times, where each of the new materializations will receive their elements from the original Sink<TIn, TMat>.

PartitionOutOfBoundsException

TBD

PartitionWith<TIn, TOut0, TOut1>

This stage partitions input to 2 different outlets, applying different transformations on the elements, according to the partition function.

Pulse<T>

Pulse stage signals demand only once every "pulse" interval and then back-pressures. Requested element is emitted downstream if there is demand. It can be used to implement simple time-window processing where data is aggregated for predefined amount of time and the computed aggregate is emitted once per this time.

RestartFlow

A RestartFlow wraps a Flow that gets restarted when it completes or fails. They are useful for graphs that need to run for longer than the Flow can necessarily guarantee it will, for example, for Flow streams that depend on a remote server that may crash or become partitioned. The RestartFlow ensures that the graph can continue running while the Flow restarts.

RestartSink

A RestartSink wraps a Sink that gets restarted when it completes or fails. They are useful for graphs that need to run for longer than the Sink can necessarily guarantee it will, for example, for Sink streams that depend on a remote server that may crash or become partitioned. The RestartSink ensures that the graph can continue running while the Sink restarts.

RestartSource

A RestartSource wraps a Source that gets restarted when it completes or fails. They are useful for graphs that need to run for longer than the Source can necessarily guarantee it will, for example, for Source streams that depend on a remote server that may crash or become partitioned. The RestartSource ensures that the graph can continue running while the Source restarts.

RestartWithBackoffFlow

RestartWithBackoffFlow.Delay

Temporary attribute that can override the time a [[RestartWithBackoffFlow]] waits for a failure before cancelling. See https://github.com/akka/akka/issues/24529 Should be removed if/when cancellation can include a cause.

Retry

ReuseLatest<T>

Reuses the latest element from upstream until it's replaced by a new value.

This is designed to allow fan-in stages where output from one of the sources is intermittent / infrequent and users just want the previous value to be reused.

ReverseOps

TBD

RunnableGraph

TBD

RunnableGraph<TMat>

A completed Akka.Streams graph that can be executed.

Sample<T>

Supports sampling on stream

Sink

TBD

Sink<TIn, TMat>

A Sink<TIn, TMat> is a set of stream processing steps that has one open input. Can be used as a Reactive.Streams.ISubscriber<T>

SinkQueueAsyncEnumerator<T>

Wraps a Sink Queue and Killswitch around System.Collections.Generic.IAsyncEnumerator<T>

Source

TBD

Source<TOut, TMat>

A Source<TOut, TMat> 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 Streams Reactive.Streams.IPublisher<T> (at least conceptually).

SourceGen

SourceOperations

TBD

SourceWithContext

SourceWithContext<TOut, TCtx, TMat>

A source that provides operations which automatically propagate the context of an element. Only a subset of common operations from FlowOperations is supported. As an escape hatch you can use [[FlowWithContextOps.via]] to manually provide the context propagation for otherwise unsupported operations.

SourceWithContextOperations

StreamConverters

Converters for interacting with the IO streams APIs

StreamRefs

API MAY CHANGE: The functionality of stream refs is working, however it is expected that the materialized value will eventually be able to remove the Task wrapping the stream references. For this reason the API is now marked as API may change. See ticket https://github.com/akka/akka/issues/24372 for more details.

Factories for creating stream refs.

StreamsAsyncEnumerableRerunnable<T, TMat>

Used to treat an IRunnableGraph<TMat> of ISinkQueue<T> as an System.Collections.Generic.IAsyncEnumerable<T>

SubFlow<TOut, TMat, TClosed>

A "stream of streams" sub-flow of data elements, e.g. produced by Akka.Streams.Implementation.Fusing.GroupBy`2. SubFlows cannot contribute to the super-flowâ€™s materialized value since they are materialized later, during the runtime of the flow graph processing.

SubFlowOperations

TBD

Tcp

TBD

TcpExt

TBD

TcpIdleTimeoutException

TcpStreamExtensions

TBD

UnexpectedOutputException

TBD

UnZip<T1, T2>

Takes a stream of pair elements and splits each pair to two output streams.

An UnZip<T1, T2> has one in port and one left and one right output port.

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 any downstream cancels

UnzipWith

TBD

UnzipWith<TIn, T0, T1>

TBD

UnzipWith<TIn, T0, T1, T2>

TBD

UnzipWith<TIn, T0, T1, T2, T3>

TBD

UnzipWith<TIn, T0, T1, T2, T3, T4>

TBD

UnzipWith<TIn, T0, T1, T2, T3, T4, T5>

TBD

UnzipWith<TIn, T0, T1, T2, T3, T4, T5, T6>

TBD

UnzipWithCreator<TIn, TOut0, TOut1>

TBD

UnzipWithCreator<TIn, TOut0, TOut1, TOut2>

TBD

UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3>

TBD

UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4>

TBD

UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5>

TBD

UnzipWithCreator<TIn, TOut0, TOut1, TOut2, TOut3, TOut4, TOut5, TOut6>

TBD

Valve<T>

Materializes into a task of IValveSwitch which provides a the method flip that stops or restarts the flow of elements passing through the stage. As long as the valve is closed it will backpressure. Note that closing the valve could result in one element being buffered inside the stage, and if the stream completes or fails while being closed, that element may be lost.