Package org.apache.pekko.stream.typed.javadsl

Class ActorFlow

java.lang.Object

org.apache.pekko.stream.typed.javadsl.ActorFlow

public class ActorFlow
extends java.lang.Object

Collection of Flows aimed at integrating with typed Actors.

Constructor Summary

Constructors

Constructor	Description
ActorFlow()

Method Summary

Modifier and Type	Method	Description
static <I,Q,A> Flow<I,A,NotUsed>	ask(int parallelism, ActorRef<Q> ref, java.time.Duration timeout, scala.Function2<I,ActorRef<A>,Q> makeMessage)	Use the ask pattern to send a request-reply message to the target ref actor.
static <I,Q,A> Flow<I,A,NotUsed>	ask(ActorRef<Q> ref, java.time.Duration timeout, java.util.function.BiFunction<I,ActorRef<A>,Q> makeMessage)	Use the ask pattern to send a request-reply message to the target ref actor.
static <I,Q,A,Ctx> Flow<Pair<I,Ctx>,Pair<A,Ctx>,NotUsed>	askWithContext(int parallelism, ActorRef<Q> ref, java.time.Duration timeout, java.util.function.BiFunction<I,ActorRef<A>,Q> makeMessage)	Use the ask pattern to send a request-reply message to the target ref actor without including the context.
static <I,Q,A,Ctx> Flow<Pair<I,Ctx>,Pair<A,Ctx>,NotUsed>	askWithContext(ActorRef<Q> ref, java.time.Duration timeout, java.util.function.BiFunction<I,ActorRef<A>,Q> makeMessage)	Use the ask pattern to send a request-reply message to the target ref actor without including the context.
static <I,Q,A> Flow<I,A,NotUsed>	askWithStatus(int parallelism, ActorRef<Q> ref, java.time.Duration timeout, java.util.function.BiFunction<I,ActorRef<StatusReply<A>>,Q> makeMessage)	Use for messages whose response is known to be a pekko.pattern.StatusReply.
static <I,Q,A> Flow<I,A,NotUsed>	askWithStatus(ActorRef<Q> ref, java.time.Duration timeout, java.util.function.BiFunction<I,ActorRef<StatusReply<A>>,Q> makeMessage)	Use for messages whose response is known to be a pekko.pattern.StatusReply.
static <I,Q,A,Ctx> Flow<Pair<I,Ctx>,Pair<A,Ctx>,NotUsed>	askWithStatusAndContext(ActorRef<Q> ref, java.time.Duration timeout, java.util.function.BiFunction<I,ActorRef<StatusReply<A>>,Q> makeMessage)	Use for messages whose response is known to be a pekko.pattern.StatusReply.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ActorFlow

public ActorFlow()

Method Detail

ask

public static <I,Q,A> Flow<I,A,NotUsed> ask(ActorRef<Q> ref,
                                                                    java.time.Duration timeout,
                                                                    java.util.function.BiFunction<I,ActorRef<A>,Q> makeMessage)

Use the ask pattern to send a request-reply message to the target ref actor. If any of the asks times out it will fail the stream with a TimeoutException.

Do not forget to include the expected response type in the method call, like so:

 flow.via(ActorFlow.<String, AskMe, String>ask(ref, timeout, (msg, replyTo) -> new AskMe(msg, replyTo)))
 // or simply
 flow.via(ActorFlow.ask(ref, timeout, AskMe::new))
 

otherwise Nothing will be assumed, which is most likely not what you want.

Defaults to parallelism of 2 messages in flight, since while one ask message may be being worked on, the second one still be in the mailbox, so defaulting to sending the second one a bit earlier than when first ask has replied maintains a slightly healthier throughput.

The operator fails with an pekko.stream.WatchedActorTerminatedException if the target actor is terminated, or with an TimeoutException in case the ask exceeds the timeout passed in.

Adheres to the pekko.stream.ActorAttributes.SupervisionStrategy attribute.

'''Emits when''' the futures (in submission order) created by the ask pattern internally are completed

'''Backpressures when''' the number of futures reaches the configured parallelism and the downstream backpressures

'''Completes when''' upstream completes and all futures have been completed and all elements have been emitted

'''Fails when''' the passed in actor terminates, or a timeout is exceeded in any of the asks performed

'''Cancels when''' downstream cancels

askWithStatus

public static <I,Q,A> Flow<I,A,NotUsed> askWithStatus(ActorRef<Q> ref,
                                                                              java.time.Duration timeout,
                                                                              java.util.function.BiFunction<I,ActorRef<StatusReply<A>>,Q> makeMessage)

Use for messages whose response is known to be a pekko.pattern.StatusReply. When a pekko.pattern.StatusReply#success response arrives the future is completed with the wrapped value, if a pekko.pattern.StatusReply#error arrives the future is instead failed.

ask

public static <I,Q,A> Flow<I,A,NotUsed> ask(int parallelism,
                                                                    ActorRef<Q> ref,
                                                                    java.time.Duration timeout,
                                                                    scala.Function2<I,ActorRef<A>,Q> makeMessage)

Use the ask pattern to send a request-reply message to the target ref actor. If any of the asks times out it will fail the stream with a TimeoutException.

Do not forget to include the expected response type in the method call, like so:

 flow.via(ActorFlow.<String, AskMe, String>ask(ref, timeout, (msg, replyTo) -> new AskMe(msg, replyTo)))
 // or simply
 flow.via(ActorFlow.ask(ref, timeout, AskMe::new))
 

otherwise Nothing will be assumed, which is most likely not what you want.

The operator fails with an pekko.stream.WatchedActorTerminatedException if the target actor is terminated, or with an TimeoutException in case the ask exceeds the timeout passed in.

Adheres to the pekko.stream.ActorAttributes.SupervisionStrategy attribute.

'''Emits when''' the futures (in submission order) created by the ask pattern internally are completed

'''Backpressures when''' the number of futures reaches the configured parallelism and the downstream backpressures

'''Completes when''' upstream completes and all futures have been completed and all elements have been emitted

'''Fails when''' the passed in actor terminates, or a timeout is exceeded in any of the asks performed

'''Cancels when''' downstream cancels

askWithStatus

public static <I,Q,A> Flow<I,A,NotUsed> askWithStatus(int parallelism,
                                                                              ActorRef<Q> ref,
                                                                              java.time.Duration timeout,
                                                                              java.util.function.BiFunction<I,ActorRef<StatusReply<A>>,Q> makeMessage)

Use for messages whose response is known to be a pekko.pattern.StatusReply. When a pekko.pattern.StatusReply#success response arrives the future is completed with the wrapped value, if a pekko.pattern.StatusReply#error arrives the future is instead failed.

askWithContext

public static <I,Q,A,Ctx> Flow<Pair<I,Ctx>,Pair<A,Ctx>,NotUsed> askWithContext(ActorRef<Q> ref,
                                                                                                                         java.time.Duration timeout,
                                                                                                                         java.util.function.BiFunction<I,ActorRef<A>,Q> makeMessage)

Use the ask pattern to send a request-reply message to the target ref actor without including the context.

askWithStatusAndContext

public static <I,Q,A,Ctx> Flow<Pair<I,Ctx>,Pair<A,Ctx>,NotUsed> askWithStatusAndContext(ActorRef<Q> ref,
                                                                                                                                  java.time.Duration timeout,
                                                                                                                                  java.util.function.BiFunction<I,ActorRef<StatusReply<A>>,Q> makeMessage)

Use for messages whose response is known to be a pekko.pattern.StatusReply. When a pekko.pattern.StatusReply#success response arrives the future is completed with the wrapped value, if a pekko.pattern.StatusReply#error arrives the future is instead failed.

askWithContext

public static <I,Q,A,Ctx> Flow<Pair<I,Ctx>,Pair<A,Ctx>,NotUsed> askWithContext(int parallelism,
                                                                                                                         ActorRef<Q> ref,
                                                                                                                         java.time.Duration timeout,
                                                                                                                         java.util.function.BiFunction<I,ActorRef<A>,Q> makeMessage)

Use the ask pattern to send a request-reply message to the target ref actor without including the context.