/// <summary> /// Shortcut for running this <see cref="Source{TOut,TMat}"/> with a reduce function. /// The given function is invoked for every received element, giving it its previous /// output (from the second element) and the element as input. /// The returned <see cref="Task{TOut}"/> will be completed with value of the final /// function evaluation when the input stream ends, or completed with Failure /// if there is a failure signaled in the stream. /// </summary> /// <param name="reduce">TBD</param> /// <param name="materializer">TBD</param> /// <returns>TBD</returns> public Task <TOut> RunSum(Func <TOut, TOut, TOut> reduce, IMaterializer materializer) => RunWith(Sink.Sum(reduce), materializer);
/// <summary> /// Shortcut for running this <see cref="Source{TOut,TMat}"/> with a foreach procedure. The given procedure is invoked /// for each received element. /// The returned <see cref="Task"/> will be completed with Success when reaching the /// normal end of the stream, or completed with Failure if there is a failure signaled in /// the stream. /// </summary> /// <param name="action">TBD</param> /// <param name="materializer">TBD</param> /// <returns>TBD</returns> public Task RunForeach(Action <TOut> action, IMaterializer materializer) => RunWith(Sink.ForEach(action), materializer);
/// <summary> /// Materializes this Source immediately. /// </summary> /// <param name="materializer">The materializer.</param> /// <returns>A tuple containing the (1) materialized value and (2) a new <see cref="Source"/> /// that can be used to consume elements from the newly materialized <see cref="Source"/>.</returns> public Tuple <TMat, Source <TOut, NotUsed> > PreMaterialize(IMaterializer materializer) { var tup = ToMaterialized(Sink.AsPublisher <TOut>(fanout: true), Keep.Both).Run(materializer); return(Tuple.Create(tup.Item1, Source.FromPublisher(tup.Item2))); }
/// <summary> /// Shortcut for running this <see cref="Source{TOut,TMat}"/> with a async <paramref name="aggregate"/> function. /// The given function is invoked for every received element, giving it its previous /// output (or the given <paramref name="zero"/> value) and the element as input. /// The returned <see cref="Task{TOut2}"/> will be completed with value of the final /// function evaluation when the input stream ends, or completed with Failure /// if there is a failure signaled in the stream. /// </summary> /// <typeparam name="TOut2">TBD</typeparam> /// <param name="zero">TBD</param> /// <param name="aggregate">TBD</param> /// <param name="materializer">TBD</param> /// <returns>TBD</returns> public Task <TOut2> RunAggregateAsync <TOut2>(TOut2 zero, Func <TOut2, TOut, Task <TOut2> > aggregate, IMaterializer materializer) => RunWith(Sink.AggregateAsync(zero, aggregate), materializer);
/// <summary> /// Wrap the given <see cref="Sink"/> with a <see cref="Sink"/> that will restart it when it fails or complete using an exponential /// backoff. /// This <see cref="Sink"/> will never cancel, since cancellation by the wrapped <see cref="Sink"/> is always handled by restarting it. /// The wrapped <see cref="Sink"/> can however be completed by feeding a completion or error into this <see cref="Sink"/>. When that /// happens, the <see cref="Sink"/>, if currently running, will terminate and will not be restarted. This can be triggered /// simply by the upstream completing, or externally by introducing a <see cref="IKillSwitch"/> right before this <see cref="Sink"/> in the /// graph. /// The restart process is inherently lossy, since there is no coordination between cancelling and the sending of /// messages. When the wrapped <see cref="Sink"/> does cancel, this <see cref="Sink"/> will backpressure, however any elements already /// sent may have been lost. /// This uses the same exponential backoff algorithm as <see cref="Akka.Pattern.Backoff"/>. /// </summary> /// <param name="sinkFactory">A factory for producing the <see cref="Sink"/> to wrap.</param> /// <param name="minBackoff">Minimum (initial) duration until the child actor will started again, if it is terminated</param> /// <param name="maxBackoff">The exponential back-off is capped to this duration</param> /// <param name="randomFactor">After calculation of the exponential back-off an additional random delay based on this factor is added, e.g. `0.2` adds up to `20%` delay. In order to skip this additional delay pass in `0`.</param> public static Sink <T, NotUsed> WithBackoff <T, TMat>(Func <Sink <T, TMat> > sinkFactory, TimeSpan minBackoff, TimeSpan maxBackoff, double randomFactor) => Sink.FromGraph(new RestartWithBackoffSink <T, TMat>(sinkFactory, minBackoff, maxBackoff, randomFactor));
/// <summary> /// Converts this Flow to a <see cref="IRunnableGraph{TMat}"/> that materializes to a Reactive Streams <see cref="IProcessor{T1,T2}"/> /// which implements the operations encapsulated by this Flow. Every materialization results in a new Processor /// instance, i.e. the returned <see cref="IRunnableGraph{TMat}"/> is reusable. /// </summary> /// <returns>A <see cref="IRunnableGraph{TMat}"/> that materializes to a <see cref="IProcessor{T1,T2}"/> when Run() is called on it.</returns> public IRunnableGraph <IProcessor <TIn, TOut> > ToProcessor() => Source.AsSubscriber <TIn>() .Via(this) .ToMaterialized(Sink.AsPublisher <TOut>(false), Keep.Both) .MapMaterializedValue(t => new FlowProcessor <TIn, TOut>(t.Item1, t.Item2) as IProcessor <TIn, TOut>);
//private readonly IRunnableGraph<(UniqueKillSwitch, ISinkQueue<T>)> _graph; public StreamsAsyncEnumerableRerunnable(Source <T, TMat> source, IMaterializer materializer) { _source = source; _materializer = materializer; thisSinkQueue = defaultSinkqueue; }
/// <summary> /// Creates a Sink which when materialized will return an <see cref="Stream"/> which it is possible /// to read the values produced by the stream this Sink is attached to. /// /// This Sink is intended for inter-operation with legacy APIs since it is inherently blocking. /// /// You can configure the default dispatcher for this Source by changing the "akka.stream.blocking-io-dispatcher" or /// set it for a given Source by using <see cref="ActorAttributes.CreateDispatcher"/>. /// /// The <see cref="Stream"/> will be closed when the stream flowing into this <see cref="Sink{TIn,TMat}"/> completes, and /// closing the <see cref="Stream"/> will cancel this <see cref="Sink{TIn,TMat}"/>. /// </summary> /// <param name="readTimeout">The max time the read operation on the materialized stream should block</param> /// <returns>TBD</returns> public static Sink <ByteString, Stream> AsInputStream(TimeSpan?readTimeout = null) { readTimeout = readTimeout ?? TimeSpan.FromSeconds(5); return(Sink.FromGraph(new InputStreamSinkStage(readTimeout.Value))); }
public static Sink <T, Task <ISourceRef <T> > > SourceRef <T>() => Sink.FromGraph <T, Task <ISourceRef <T> > >(new SinkRefStageImpl <T>(null));