All Classes and Interfaces
Class
Description
INTERNAL API
Signal that the operator 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.A base exception for abrupt stream termination.
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.
Java API: compatible with lambda expressions
The actor context - the view of the actor cell from the actor.
Defines which messages the Actor can handle, along with the implementation of
how the messages should be processed.
Java API: compatible with lambda expressions
Java API: compatible with lambda expressions
Java API: Support for scheduled
self messages via TimerScheduler.Java API: compatible with lambda expressions
Java API: compatible with lambda expressions
An actor
Behavior can be implemented by extending this class and implement the
abstract method AbstractBehavior.createReceive().An actor
Behavior can be implemented by extending this class and implement the
abstract method AbstractBehavior.onMessage(T) and optionally override
AbstractBehavior.onSignal().Lock-free bounded non-blocking multiple-producer single-consumer queue based on the works of:
Andriy Plokhotnuyk (https://github.com/plokhotnyuk)
- https://github.com/plokhotnyuk/actors/blob/2e65abb7ce4cbfcb1b29c98ee99303d6ced6b01f/src/test/scala/akka/dispatch/Mailboxes.scala
(Apache V2: https://github.com/plokhotnyuk/actors/blob/master/LICENSE)
Dmitriy Vyukov's non-intrusive MPSC queue:
- https://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
(Simplified BSD)
Java API: Interface for implementing a
DeltaReplicatedData in Java.Java API for ExtensionId
Scala 2.11 API: Each extension typically provide a concrete
ExtensionSetup that can be used in
pekko.actor.setup.ActorSystemSetup when starting the ActorSystem to replace the default
implementation of the extension.Java API: compatible with lambda expressions
Java API: compatible with lambda expressions
Java API: compatible with lambda expressions
Java API: A GraphStage represents a reusable graph stream processing operator.
Java API: callbacks for an input port where termination logic is predefined
(completing when upstream completes, failing when upstream fails).
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).
Common logic for the least shard allocation strategy implementations
Java API: compatible with lambda expressions
Java API: compatible with lambda expressions
Lock-free MPSC linked queue implementation based on Dmitriy Vyukov's non-intrusive MPSC queue:
https://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
This queue could be wait-free (i.e.
Java API: callbacks for an output port where termination logic is predefined
(completing when downstream cancels).
Java API: an persistent actor - can be used to implement command or Event Sourcing.
INTERNAL API
Java API: compatible with lambda expressions
Java API: Combination of
AbstractPersistentActor and pekko.actor.AbstractActorWithTimers.Deprecated.
Use EventSourcedBehavior.
Deprecated.
Use EventSourcedBehavior.
Deprecated.
Use EventSourcedBehavior.
Deprecated.
Use EventSourcedBehavior.
Java API: Factory for Props instances.
Java API: Interface for implementing a
ReplicatedData in Java.An Apache Pekko scheduler service.
Java API
Java API for creating custom
Shape types.INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
Actor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model':
https://en.wikipedia.org/wiki/Actor_model
emptyBehavior is a Receive-expression that matches no messages at all, ever.
ignoringBehavior is a Receive-expression that consumes and ignores all messages.
INTERNAL API
Attributes for the
Materializer.Enables additional low level troubleshooting logging at DEBUG log level
Configures the dispatcher to be used by streams.
Test utility: fuzzing mode means that GraphStage events are not processed
in FIFO order within a fused subgraph, but randomized.
Configure the maximum buffer size for which a FixedSizeBuffer will be preallocated.
Maximum number of elements emitted in batch if downstream signals large demand.
Defines a timeout for stream subscription and what action to take when that hits.
Limit for number of messages that can be processed synchronously in stream to substream communication.
Attributes for the
Materializer.Everything in here is completely Pekko PRIVATE.
INTERNAL API
Can be mixed into an EventBus to specify that the Classifier type is ActorRef
The actor context - the view of the actor cell from the actor.
An Actor is given by the combination of a
Behavior and a context in
which this behavior is executed.An Actor is given by the combination of a
Behavior and a context in
which this behavior is executed.INTERNAL API
INTERNAL API
Represents an EventBus where the Subscriber type is ActorRef
INTERNAL API
INTERNAL API
Collection of Flows aimed at integrating with typed Actors.
Collection of Flows aimed at integrating with typed Actors.
Collection of Flows aimed at integrating with typed Actors.
Collection of Flows aimed at integrating with typed Actors.
Reply to
pekko.actor.Identify.An ActorInitializationException is thrown when the initialization logic for an Actor fails.
When an InterruptedException is thrown inside an Actor, it is wrapped as an ActorInterruptedException as to
avoid cascading interrupts to other threads than the originally interrupted one.
ActorKilledException is thrown when an Actor receives the
pekko.actor.Kill messageScala API: Mix in ActorLogging into your Actor to easily obtain a reference to a logger,
which is available under the name "log".
This is public with the purpose to document the used markers and properties of log events.
This is public with the purpose to document the used markers and properties of log events.
This class describes the configurable properties of the
ActorMaterializer.INTERNAL API
INTERNAL API
When
ActorSelection.resolveOne(org.apache.pekko.util.Timeout) can't identify the actor the
Future is completed with this failure.Actor path is a unique path to an actor that shows the creation path
up through the actor tree to the root actor.
Given an ActorPath it returns the Address and the path elements if the path is well-formed
Given an ActorPath it returns the Address and the path elements if the path is well-formed
Java API
Java API
Immutable and serializable handle to an actor, which may or may not reside
on the local host or inside the same
pekko.actor.ActorSystem.An ActorRef is the identity or address of an Actor instance.
INTERNAL API
Interface implemented by ActorSystem and ActorContext, the only two places
from which you can get fresh actors.
INTERNAL API
INTERNAL API
Every ActorRef is also an ActorRefImpl, but these two methods shall be
completely hidden from client code.
INTERNAL API: Adds support for serializing and deserializing
ActorRef.Interface for all ActorRef providers to implement.
Serialization and deserialization of
ActorRef.Can be used in
pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the ActorRefResolver extension.INTERNAL API: Thread local cache per actor system
Routee that sends the messages to an pekko.actor.ActorRef.All ActorRefs have a scope which describes where they live.
INTERNAL API
An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors,
allowing for broadcasting of messages to that section.
An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors,
allowing for broadcasting of messages to that section.
Routee that sends the messages to an pekko.actor.ActorSelection.Collection of Sinks aimed at integrating with typed Actors.
Collection of Sinks aimed at integrating with typed Actors.
Collection of Sinks aimed at integrating with typed Actors.
Collection of Sinks aimed at integrating with typed Actors.
Collection of Sources aimed at integrating with typed Actors.
Collection of Sources aimed at integrating with typed Actors.
Collection of Sources aimed at integrating with typed Actors.
Collection of Sources aimed at integrating with typed Actors.
An actor system is a hierarchical group of actors which share common
configuration, e.g.
An ActorSystem is home to a hierarchy of Actors.
Settings are the overall ActorSystem Settings which also provides a convenient access to the Config object.
INTERNAL API
INTERNAL API
INTERNAL API
Abstract bundle activator implementation to bootstrap and configure an actor system in an
OSGi environment.
A set of setup settings for programmatic configuration of the actor system.
Actor tags are used to logically group actors.
Java API: Test kit for asynchronous testing of typed actors.
Testkit for asynchronous testing of typed actors, meant for mixing into the test class.
A base class for the
ActorTestKit, making it possible to have testing framework (e.g.INTERNAL API
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Adapters between typed and classic actors and actor systems.
Adapters between typed and classic actors and actor systems.
INTERNAL API:
Internal API
A router group that performs load balancing of messages to cluster nodes based on
cluster metric data.
A router pool that performs load balancing of messages to cluster nodes based on
cluster metric data.
Load balancing of messages to cluster nodes based on cluster metric data.
The address specifies the physical location under which an Actor can be
reached.
INTERNAL API
This object serves as extractor for Scala and as address parser for Java.
This object serves as extractor for Scala and as address parser for Java.
INTERNAL API: Adds support for serializing and deserializing
Address.INTERNAL API
INTERNAL API
Extension that holds a uid that is assigned as a random
Long or Int depending
on which version of remoting that is used.INTERNAL API
INTERNAL API
Add a routee by sending this message to the router.
Increase or decrease the number of routees in a
Pool.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Subscribe to this class to be notified about all
DeadLetter (also the suppressed ones)
and Dropped.Applies the fault handling
Directive (Resume, Restart, Stop) specified in the Decider
to all children when one fails, as opposed to pekko.actor.OneForOneStrategy that applies
it only to the child actor that failed.INTERNAL API
INTERNAL API
This type of
Shape can express any number of inputs and outputs at the
expense of forgetting about their specific types.Marks APIs that are meant to evolve towards becoming stable APIs, but are not stable APIs yet.
INTERNAL API
*
Defines a remote address.
*
Defines a remote address.
RemoteWatcher.ArteryHeartbeat is empty array
RemoteWatcher.ArteryHeartbeatRsp
RemoteWatcher.ArteryHeartbeat is empty array
RemoteWatcher.ArteryHeartbeatRsp
CompressionProtocol.ActorRefCompressionAdvertisement
CompressionProtocol.ClassManifestCompressionAdvertisement
CompressionProtocol.ActorRefCompressionAdvertisement
CompressionProtocol.ClassManifestCompressionAdvertisement
CompressionProtocol.ActorRefCompressionAdvertisementAck
CompressionProtocol.ClassManifestCompressionAdvertisementAck
CompressionProtocol.ActorRefCompressionAdvertisementAck
CompressionProtocol.ClassManifestCompressionAdvertisementAck
Protobuf type
FlushAckProtobuf type
FlushAckProtobuf type
HandshakeReqProtobuf type
HandshakeReq
Generic message declaration that is used for all types of message that (currently) have a single
address field.
Generic message declaration that is used for all types of message that (currently) have a single
address field.
Protobuf type
QuarantinedProtobuf type
Quarantined
SystemMessageDelivery.Ack
SystemMessageDelivery.Nack
SystemMessageDelivery.Ack
SystemMessageDelivery.Nack
SystemMessageDelivery.SystemMessageEnvelope
SystemMessageDelivery.SystemMessageEnvelope
*
Defines a remote address with uid.
*
Defines a remote address with uid.
INTERNAL API: marker trait for protobuf-serializable artery messages
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
The ask-pattern implements the initiator side of a request–reply protocol.
The ask-pattern implements the initiator side of a request–reply protocol.
The ask-pattern implements the initiator side of a request–reply protocol.
The ask-pattern implements the initiator side of a request–reply protocol.
This object contains implementation details of the “ask” pattern.
This is what is used to complete a Future that is returned from an ask/? call,
when it times out.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Class to convert ordinary
pekko.actor.ActorRef instances to a HandleEventListener.Message sent to the listener registered to an association
Supertype of possible disassociation reasons
Trait for events that the registered listener for an
pekko.remote.transport.AssociationHandle might receive.An interface that needs to be implemented by the user of an
pekko.remote.transport.AssociationHandle
to listen to association events.Message sent to the listener registered to an association (via the Promise returned by
pekko.remote.transport.AssociationHandle#readHandlerPromise) when an inbound payload arrives.Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
An asynchronous callback holder that is attached to a
GraphStageLogic.INTERNAL API
INTERNAL API
Asynchronous message replay and sequence number recovery interface.
Java API: asynchronous message replay and sequence number recovery interface.
Thrown if replay inactivity exceeds a specified timeout.
Serializer that supports async serialization.
Scala API: Async serializer with string manifest that delegates synchronous calls to the asynchronous calls
and blocks.
Java API: Async serializer with string manifest that delegates synchronous calls to the asynchronous calls
and blocks.
Abstract journal, optimized for asynchronous, non-blocking writes.
Java API: abstract journal, optimized for asynchronous, non-blocking writes.
INTERNAL API.
INTERNAL API.
INTERNAL API.
INTERNAL API.
INTERNAL API.
Scala API: Mix-in this trait with your
PersistentActor to send messages with at-least-once
delivery semantics to destinations.Snapshot of current
AtLeastOnceDelivery state.INTERNAL API
Information about a message that has not been confirmed.
Holds attributes which can be used to alter
pekko.stream.scaladsl.Flow / pekko.stream.javadsl.Flow
or pekko.stream.scaladsl.GraphDSL / pekko.stream.javadsl.GraphDSL materialization.Note that more attributes for the
Materializer are defined in ActorAttributes.Cancellation strategies provide a way to configure the behavior of a stage when
cancelStage is called.Strategy that allows to delay any action when
cancelStage is invoked.Strategy that treats
cancelStage the same as completeStage, i.e.Strategy that treats
cancelStage the same as failStage, i.e.Strategy that treats
cancelStage in different ways depending on the cause that was given to the cancellation.Each asynchronous piece of a materialized stream topology is executed by one Actor
that manages an input buffer for all inlets of its shape.
Attributes that are always present (is defined with default values by the materializer)
Nested materialization cancellation strategy provides a way to configure the cancellation behavior of stages that materialize a nested flow.
Attribute that contains the source location of for example a lambda passed to an operator, useful for example
for debugging.
Note that more attributes for the
Materializer are defined in ActorAttributes.INTERNAL API
Backoff options allow to specify a number of properties for backoff supervisors.
Backoff options allow to specify a number of properties for backoff supervisors.
Send this message to the
BackoffSupervisor and it will reply with
BackoffSupervisor.CurrentChild containing the ActorRef of the current child, if any.Send this message to the
BackoffSupervisor and it will reply with
BackoffSupervisor.CurrentChild containing the ActorRef of the current child, if any.Send this message to the
BackoffSupervisor and it will reply with
BackoffSupervisor.RestartCount containing the current restart count.Send this message to the
BackoffSupervisor and it will reset the back-off.INTERNAL API
Not for user extension
Fan-out the stream to several streams.
Fan-out the stream to several streams.
Fan-out the stream to several streams.
Configurator for creating
pekko.dispatch.BalancingDispatcher.INTERNAL API
A router pool that will try to redistribute work from busy routees to idle routees.
INTERNAL API
Can't be in the
BalancingPool companion for binary compatibility reasons.INTERNAL API
Can't be in the
BalancingPool companion for binary compatibility reasons.INTERNAL API
INTERNAL API.
Base serializer trait with serialization identifiers configuration contract,
when globally unique serialization identifier is configured in the
reference.conf.INTERNAL API
INTERNAL API
The behavior of an actor defines how it reacts to the messages that it
receives.
Immutable builder used for creating a
Behavior by 'chaining' message and signal handlers.INTERNAL API
Similar to
BehaviorImpl.ReceiveBehavior however onMessage does not accept context.INTERNAL API
A behavior interceptor allows for intercepting message and signal reception and perform arbitrary logic -
transform, filter, send to a side channel etc.
Abstraction of passing the on further in the behavior stack in
BehaviorInterceptor.aroundStart(org.apache.pekko.actor.typed.TypedActorContext<Outer>, org.apache.pekko.actor.typed.BehaviorInterceptor.PreStartTarget<Inner>).Abstraction of passing the message on further in the behavior stack in
BehaviorInterceptor.aroundReceive(org.apache.pekko.actor.typed.TypedActorContext<Outer>, Outer, org.apache.pekko.actor.typed.BehaviorInterceptor.ReceiveTarget<Inner>).Abstraction of passing the signal on further in the behavior stack in
BehaviorInterceptor.aroundReceive(org.apache.pekko.actor.typed.TypedActorContext<Outer>, Outer, org.apache.pekko.actor.typed.BehaviorInterceptor.ReceiveTarget<Inner>).Factories for
pekko.actor.typed.Behavior.Factories for
pekko.actor.typed.Behavior.Behavior that exposes additional fluent DSL methods to further change the message or
signal reception behavior.Factories for
pekko.actor.typed.Behavior.Factories for
pekko.actor.typed.Behavior.INTERNAL API
A behavior interceptor allows for intercepting signals reception and perform arbitrary logic -
transform, filter, send to a side channel etc.
INTERNAL API
INTERNAL API
Used for synchronous testing
pekko.actor.typed.Behaviors.Used for synchronous testing
pekko.actor.typed.Behaviors.A bidirectional flow of elements that consequently has two inputs and two
outputs, arranged like this:
Extension provides access to bound addresses.
BoundedBlockingQueue wraps any Queue and turns the result into a BlockingQueue with a limited capacity.
BoundedControlAwareMailbox is a bounded MailboxType, that maintains two queues
to allow messages that extend
pekko.dispatch.ControlMessage to be delivered with priority.BoundedDequeBasedMailbox is an bounded MailboxType, backed by a Deque.
BoundedMessageQueueSemantics adds bounded semantics to a DequeBasedMessageQueue,
i.e.
BoundedMailbox is the default bounded MailboxType used by Pekko Actors.
BoundedMessageQueueSemantics adds bounded semantics to a QueueBasedMessageQueue,
i.e.
Lock-free bounded non-blocking multiple-producer single-consumer queue.
BoundedPriorityMailbox is a bounded mailbox that allows for prioritization of its contents.
A queue of the given size that gives immediate feedback whether an element could be enqueued or not.
BoundedStablePriorityMailbox is a bounded mailbox that allows for prioritization of its contents.
Used to broadcast a message to all routees in a router; only the
contained message will be forwarded, i.e.
Fan-out the stream to several streams.
Fan-out the stream to several streams emitting each incoming upstream element to all downstream consumers.
Fan-out the stream to several streams.
A router group that broadcasts a message to all its routees.
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
A router pool that broadcasts a message to all its routees.
Broadcasts a message to all its routees.
INTERNAL API
The concrete behavior
Receive type for
AbstractBehaviorpekko.event.LoggingAdapter that publishes pekko.event.Logging.LogEvent to event stream.This is a special Serializer that Serializes and deserializes byte arrays only,
(just returns the byte array unchanged/uncopied)
Serializer between an object and a
ByteBuffer representing that object.INTERNAL API
An iterator over a ByteString.
A rope-like immutable data structure containing bytes.
An unfragmented ByteString.
INTERNAL API: ByteString backed by exactly one array, with start / end markers
A compact (unsliced) and unfragmented ByteString, implementation of ByteString1C.
A ByteString with 2 or more fragments.
A mutable builder for efficiently creating a
ByteString.INTERNAL API
INTERNAL API
INTERNAL API
Dispatcher which runs invocations on the current thread only.
Signifies something that can be cancelled
There is no strict guarantee that the implementation is thread-safe,
but it should be good practice to make it so.
A MetricsSelector producing weights from remaining capacity.
Representation of a Log Event issued by a
pekko.actor.typed.Behavior
when testing with pekko.actor.testkit.typed.scaladsl.BehaviorTestKit
or pekko.actor.testkit.typed.javadsl.BehaviorTestKit.INTERNAL API
INTERNAL API
Implementations of this interface are sent as actor messages back to a channel actor as
a result of it having called
register on the ChannelRegistry.Interface behind which we hide our selector management logic from the connection actors
Child has failed due an uncaught exception
INTERNAL API
INTERNAL API
INTERNAL API
This is the empty container, shared among all leaf actors.
Normal children container: we do have at least one child, but none of our
children are currently terminating (which is the time period between
calling context.stop(child) and processing the ChildTerminated() system
message).
This is the empty container which is installed after the last child has
terminated while stopping; it is necessary to distinguish from the normal
empty state while calling handleChildTerminated() for the last time.
Waiting state: there are outstanding termination requests (i.e.
INTERNAL API
ChildRestartStats is the statistics kept by every parent Actor for every child Actor
and is used for SupervisorStrategies to know how to deal with problems that occur for the children.
INTERNAL API
Provides circuit breaker functionality for stability when working with "dangerous" operations, e.g.
Internal state abstraction
Companion object providing factory methods for Circuit Breaker which runs callbacks in caller's thread
INTERNAL API
INTERNAL API
Exception thrown when Circuit Breaker is open.
A CircuitBreakersPanel is a central point collecting all circuit breakers in Akka.
Companion object providing factory methods for Circuit Breaker which runs callbacks in caller's thread
Service Provider Interface (SPI) for collecting metrics from Circuit Breaker.
INTERNAL API
INTERNAL API
INTERNAL API
Glue API introduced to allow minimal user effort integration between classic and typed for example for streams.
Glue API introduced to allow minimal user effort integration between classic and typed for example for streams.
ClassLoaderObjectInputStream tries to utilize the provided ClassLoader to load Classes and falls
back to ObjectInputStreams resolver.
INTERNAL API.
The client is usually the side that consumes the service provided by its
interlocutor.
INTERNAL API.
INTERNAL API.
This
Shape is used for graphs that have neither open inputs nor open
outputs.This module is responsible cluster membership information.
This class is not intended for user extension other than for test purposes (e.g.
Cluster Extension Id and factory for creating Cluster extension.
Pekko Typed Cluster API entry point
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
INTERNAL API
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Declares a super type for all events emitted by the
ClusterReceptionist.Marker trait for remote messages with special serializer.
Protobuf type
ContactsProtobuf type
ContactsDeprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
The reply to
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Deprecated.
Use Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Emitted to the Pekko event stream when a cluster client was previously connected
but then not seen for some time.
Emitted to the Pekko event stream when a cluster client has interacted with
a receptionist.
Not intended for user extension.
INTERNAL API.
Domain events published to the event bus.
Marker interface for cluster domain events.
This event is published when the cluster node is shutting down,
before the final
ClusterEvent.MemberRemoved events are published.Current snapshot state of the cluster.
Marker interface to facilitate subscription of
both
ClusterEvent.UnreachableDataCenter and ClusterEvent.ReachableDataCenter.When using this subscription mode the events corresponding
to the current state will be sent to the subscriber to mimic what you would
have seen if you were listening to the events when they occurred in the past.
When using this subscription mode a snapshot of
pekko.cluster.ClusterEvent.CurrentClusterState will be sent to the
subscriber as the first message.Leader of the cluster data center of this node changed.
Member status changed to
MemberStatus.Down and will be removed
when all members have seen the Down status.Marker interface for membership events.
Member status changed to
MemberStatus.Exiting and will be removed
when all members have seen the Exiting status.Member status changed to Joining.
Member status changed to Leaving.
Member completely removed from the cluster.
Member status changed to Up.
Member status changed to WeaklyUp.
Marker interface to facilitate subscription of
both
ClusterEvent.UnreachableMember and ClusterEvent.ReachableMember.A data center is considered reachable when all members from the data center are reachable
A member is considered as reachable by the failure detector
after having been unreachable.
First member (leader) of the members within a role set (in the same data center as this node,
if data centers are used) changed.
A data center is considered as unreachable when any members from the data center are unreachable
A member is considered as unreachable by the failure detector.
Domain events published to the event bus.
INTERNAL API: Utilities to obtain ClusterHeartbeatReceiver paths
INTERNAL API
INTERNAL API
INTERNAL API
This is public with the purpose to document the used markers and properties of log events.
INTERNAL API
This is public with the purpose to document the used markers and properties of log events.
Base trait for all cluster messages.
*
Defines a remote address.
*
Defines a remote address.
Protobuf type
ClusterRouterPoolProtobuf type
ClusterRouterPoolProtobuf type
ClusterRouterPoolSettingsProtobuf type
ClusterRouterPoolSettingsProtobuf type
ConfigCheckProtobuf type
ConfigCheckProtobuf enum
ConfigCheck.Type
*
An empty message
*
An empty message
*
Gossip
*
Gossip
*
Gossip Envelope
*
Gossip Envelope
*
Gossip Overview
*
Gossip Overview
*
Gossip Status
*
Gossip Status
*
Prior to version 2.5.24
Heartbeat sends an Address
Version 2.5.24 can deserialize this message but does not send it.
*
Prior to version 2.5.24
Heartbeat sends an Address
Version 2.5.24 can deserialize this message but does not send it.
*
Prior to version 2.5.24
HeartbeatRsp Sends an UniqueAddress
Version 2.5.24 can deserialize this message but does not send it.
*
Prior to version 2.5.24
HeartbeatRsp Sends an UniqueAddress
Version 2.5.24 can deserialize this message but does not send it.
*
InitJoin
*
InitJoin
*
InitJoinAck
*
InitJoinAck
*
Join
*
Join
*
Member
*
Member
*
Member Status
*
Reachability
*
Reachability
Protobuf type
PoolProtobuf type
PoolProtobuf type
org.apache.pekko.cluster.typed.PubSubMessagePublishedProtobuf type
org.apache.pekko.cluster.typed.PubSubMessagePublished
*
Reachability status
Protobuf type
org.apache.pekko.cluster.typed.ReceptionistEntryProtobuf type
org.apache.pekko.cluster.typed.ReceptionistEntryProtobuf type
SubjectReachabilityProtobuf type
SubjectReachabilityProtobuf type
TombstoneProtobuf type
Tombstone
*
Defines a remote address with uid.
*
Defines a remote address with uid.
*
Vector Clock
*
Vector Clock
Protobuf type
VectorClock.VersionProtobuf type
VectorClock.Version
*
Welcome, reply to Join
*
Welcome, reply to Join
Protobuf serializer of cluster messages.
INTERNAL API
Current snapshot of cluster node metrics.
INTERNAL API.
Local cluster metrics extension events.
Cluster metrics extension.
Cluster metrics extension provider.
INTERNAL API.
Protobuf type
AdaptiveLoadBalancingPoolProtobuf type
AdaptiveLoadBalancingPool
*
Defines a remote address.
*
Defines a remote address.
*
Metrics Gossip
*
Metrics Gossip
*
Metrics Gossip Envelope
*
Metrics Gossip Envelope
couldn't figure out how to import Payload
couldn't figure out how to import Payload
Protobuf type
MixMetricsSelectorProtobuf type
MixMetricsSelector
*
Node Metrics
*
Node Metrics
Protobuf type
NodeMetrics.EWMAProtobuf type
NodeMetrics.EWMAProtobuf type
NodeMetrics.MetricProtobuf type
NodeMetrics.MetricProtobuf type
NodeMetrics.NumberProtobuf type
NodeMetrics.NumberProtobuf enum
NodeMetrics.NumberTypeMetrics extension settings.
Default
ClusterMetricsSupervisor strategy:
A configurable pekko.actor.OneForOneStrategy with restart-on-throwable decider.Provide custom metrics strategy resources.
Interface for the cluster JMX MBean.
INTERNAL API
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
INTERNAL API
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
INTERNAL API
INTERNAL API
INTERNAL API
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Deprecated.
Use Apache Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc.
Internal API
INTERNAL API
INTERNAL API
The router actor, subscribes to cluster events and
adjusts the routees.
INTERNAL API
pekko.routing.RouterConfig implementation for deployment on cluster nodes.totalInstances of cluster router must be > 0pekko.routing.RouterConfig implementation for deployment on cluster nodes.totalInstances of cluster router must be > 0
maxInstancesPerNode of cluster router must be > 0
maxInstancesPerNode of cluster router must be 1 when routeesPath is definedINTERNAL API
INTERNAL API
Cluster aware scope of a
pekko.actor.DeployCan be used in
pekko.actor.setup.ActorSystemSetup when starting the pekko.actor.typed.ActorSystem
to replace the default implementation of the Cluster extension.This extension provides sharding functionality of actors in a cluster.
This extension provides sharding functionality of actors in a cluster.
The entity can request passivation by sending the
ClusterSharding.Passivate message
to the ActorRef[ShardCommand] that was passed in to the factory method
when creating the entity.The entity can request passivation by sending the
ClusterSharding.Passivate message
to the ActorRef[ShardCommand] that was passed in to the factory method
when creating the entity.When an entity is created an
ActorRef[ShardCommand] is passed to the
factory method.When an entity is created an
ActorRef[ShardCommand] is passed to the
factory method.This extension provides sharding functionality of actors in a cluster.
INTERNAL API.
INTERNAL API (ctr)
Internal API
Protobuf type
ActorRefMessageProtobuf type
ActorRefMessage
*
Defines a remote address.
*
Defines a remote address.
Protobuf type
ClusterShardingStatsProtobuf type
ClusterShardingStatsProtobuf type
ClusterShardingStatsEntryProtobuf type
ClusterShardingStatsEntryProtobuf type
CoordinatorStateProtobuf type
CoordinatorStateProtobuf type
CoordinatorState.ShardEntryProtobuf type
CoordinatorState.ShardEntryProtobuf type
CurrentRegionsProtobuf type
CurrentRegionsProtobuf type
CurrentShardRegionStateProtobuf type
CurrentShardRegionStateProtobuf type
CurrentShardStateProtobuf type
CurrentShardStateProtobuf type
EntitiesStartedProtobuf type
EntitiesStartedProtobuf type
EntitiesStoppedProtobuf type
EntitiesStopped
not written anymore but kept for backwards compatibility
not written anymore but kept for backwards compatibility
Protobuf type
EntityStateProtobuf type
EntityState
not written anymore but kept for backwards compatibility
not written anymore but kept for backwards compatibility
Protobuf type
GetClusterShardingStatsProtobuf type
GetClusterShardingStatsProtobuf type
MapFieldEntryProtobuf type
MapFieldEntryProtobuf type
RememberedShardStateProtobuf type
RememberedShardStateProtobuf type
ShardHomeProtobuf type
ShardHomeProtobuf type
ShardHomeAllocatedProtobuf type
ShardHomeAllocatedProtobuf type
ShardHomesProtobuf type
ShardHomes
only used nested in ShardHomes
only used nested in ShardHomes
Protobuf type
ShardIdMessageProtobuf type
ShardIdMessageProtobuf type
ShardRegionStatsProtobuf type
ShardRegionStatsProtobuf type
ShardStateProtobuf type
ShardStateProtobuf type
ShardStatsProtobuf type
ShardStatsProtobuf type
StartEntityProtobuf type
StartEntityProtobuf type
StartEntityAckProtobuf type
StartEntityAckProtocol for querying sharding state e.g.
Marker trait for remote messages and persistent events/snapshots with special serializer.
param: role specifies that this entity type requires cluster nodes with a specific role.
param: numberOfShards number of shards used by the default
HashCodeMessageExtractor
param: role Specifies that this entity type requires cluster nodes with a specific role.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Determine the passivation strategy to use from settings.
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
Can be used in
pekko.actor.setup.ActorSystemSetup when starting the pekko.actor.typed.ActorSystem
to replace the default implementation of the ClusterSharding extension.This class is not intended for user extension other than for test purposes (e.g.
INTERNAL API:
INTERNAL API:
Manages singleton actor instance among all cluster nodes or a group
of nodes tagged with a specific role.
INTERNAL API
public due to the
with FSM type parametersINTERNAL API
Request to deliver one more event.
The first event, corresponding to CurrentClusterState.
INTERNAL API
public due to the
with FSM type parametersThrown when a consistent state can't be determined within the
defined retry limits.
param: singletonName The actor name of the child singleton actor.
param: singletonName The actor name of the child singleton actor.
Marker trait for remote messages with special serializer.
The
ClusterSingletonProxy works together with the pekko.cluster.singleton.ClusterSingletonManager to provide a
distributed proxy to the singleton actor.param: singletonName The actor name of the singleton actor that is started by the
ClusterSingletonManager.Can be used in
pekko.actor.setup.ActorSystemSetup when starting the pekko.actor.typed.ActorSystem
to replace the default implementation of the ClusterSingleton extension.Messages for subscribing to changes in the cluster state
INTERNAL API
Cluster commands sent by the USER via
pekko.cluster.Cluster extension
or JMX.Command to mark node as temporary down.
Command to initiate join another node (represented by
address).Command to leave the cluster.
Command to mark all nodes as shutting down
INTERNAL API
Cluster commands sent by the USER via
pekko.cluster.Cluster extension
or JMX.Runtime collection management commands.
INTERNAL API
INTERNAL API
Command for
ClusterMetricsSupervisor to start metrics collection.Command for
ClusterMetricsSupervisor to start metrics collection.Command for
ClusterMetricsSupervisor to stop metrics collection.Command for
ClusterMetricsSupervisor to stop metrics collection.INTERNAL API
INTERNAL API
FunctionalInterface for reacting on commands
FunctionalInterface for reacting on commands
FunctionalInterface for reacting on commands
FunctionalInterface for reacting on commands
INTERNAL API
A compact ByteString.
INTERNAL API.
CompletionStages provides utilities for working with
CompletionStages.CompletionStages provides utilities for working with
CompletionStages.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Takes two streams and outputs an output stream formed from the two input streams
by consuming one stream first emitting all of its elements, then consuming the
second stream emitting all of its elements.
Takes multiple streams and outputs one stream formed from the input streams
by first emitting all of the elements from the first stream and then emitting
all of the elements from the second stream, etc.
Takes two streams and outputs an output stream formed from the two input streams
by consuming one stream first emitting all of its elements, then consuming the
second stream emitting all of its elements.
INTERNAL API
INTERNAL API
An implementation of a ConcurrentMultiMap
Adds/remove is serialized over the specified key
Reads are fully concurrent <-- el-cheapo
The conductor is the one orchestrating the test: it governs the
pekko.remote.testconductor.Controller’s port to which all
pekko.remote.testconductor.Players connect, it issues commands to their
org.apache.pekko.remote.testconductor.NetworkFailureInjector and provides support
for barriers using the pekko.remote.testconductor.BarrierCoordinator.INTERNAL API
INTERNAL API
Config in pekko.remote.artery.ssl.config-ssl-engine
Deprecated.
Classic remoting is deprecated, use Artery.
This exception is thrown when Apache Pekko detects a problem with the provided configuration
Not for user extension
Consistent Hashing node ring implementation.
A router group that uses consistent hashing to select a routee based on the
sent message.
A router pool that uses consistent hashing to select a routee based on the
sent message.
If you don't define the
hashMapping when
constructing the pekko.routing.ConsistentHashingRouter
the messages need to implement this interface to define what
data to use for the consistent hash key.If you don't define the
hashMapping when
constructing the pekko.routing.ConsistentHashingRouter
and messages can't implement pekko.routing.ConsistentHashingRouter.ConsistentHashable
themselves they can we wrapped by this envelope instead.JAVA API
Mapping from message to the data to use for the consistent hash key.
INTERNAL API
INTERNAL API
When the message has been processed the consumer is supposed to send
Confirmed back
to the ConsumerController via the confirmTo in the ConsumerController.Delivery message.Received messages from the producer are wrapped in
Delivery when sent to the consumer.Register the
ConsumerController to the given producerController.Initial message from the consumer actor.
For commands defined in public ConsumerController
INTERNAL API
Emitted to a subscriber when contact points have been
received by the ClusterClient and a new one has been added.
Declares a super type for all events emitted by the
ClusterClient
in relation to contact points being added or removed.Emitted to a subscriber when contact points have been
received by the ClusterClient and a new one has been added.
The reply to
Protobuf type
ActorIdentityProtobuf type
ActorIdentityProtobuf type
ActorInitializationExceptionProtobuf type
ActorInitializationExceptionProtobuf type
ActorRefProtobuf type
ActorRefProtobuf type
IdentifyProtobuf type
IdentifyProtobuf type
OptionProtobuf type
OptionProtobuf enum
PatternTypeProtobuf type
PayloadProtobuf type
PayloadProtobuf type
SelectionProtobuf type
SelectionProtobuf type
SelectionEnvelopeProtobuf type
SelectionEnvelopeProtobuf type
StackTraceElementProtobuf type
StackTraceElement
ReplyWith pattern message(s)
ReplyWith pattern message(s)
Protobuf type
ThrowableProtobuf type
ThrowableProtobuf type
ThrowableNotSerializableProtobuf type
ThrowableNotSerializableProtobuf type
WatcherHeartbeatResponseProtobuf type
WatcherHeartbeatResponseControlAwareMessageQueue handles messages that extend
pekko.dispatch.ControlMessage with priority.INTERNAL API.
Messages that extend this trait will be handled with priority by control aware mailboxes.
INTERNAL API
Marker trait for control messages that can be sent via the system message sub-channel
but don't need full reliable delivery.
Reason for the shutdown, which can be used by tasks in case they need to do
different things depending on what caused the shutdown.
INTERNAL API
INTERNAL API
INTERNAL API: Count-Min Sketch datastructure.
MetricsSelector that uses the combined CPU time metrics and stolen CPU time metrics.
MetricsSelector that uses the combined CPU time metrics and stolen CPU time metrics.
A constructor/factory, takes no parameters but creates a new value of type T every call.
INTERNAL API
INTERNAL API
A plugin may optionally support this query by implementing this interface.
A plugin may optionally support this query by implementing this trait.
A plugin may optionally support this query by implementing this trait.
A plugin may optionally support this query by implementing this trait.
A plugin may optionally support this query by implementing this interface.
A plugin may optionally support this query by implementing this trait.
A trait that enables querying the current last sequence number for a given
persistenceId.A trait that enables querying the current last sequence number for a given
persistenceId.A plugin may optionally support this query by implementing this interface.
A plugin may optionally support this query by implementing this trait.
INTERNAL API
INTERNAL API
Custom event filter when the others do not fit the bill.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
When a message is sent to an Actor that is terminated before receiving the message, it will be sent as a DeadLetter
to the ActorSystem's EventStream.
Use with caution: Messages extending this trait will not be logged by the default dead-letters listener.
Implementation of failure detector using an absolute timeout of missing heartbeats
to trigger unavailability.
A DeathPactException is thrown by an Actor that receives a Terminated(someActor) message
that it doesn't handle itself, effectively crashing the Actor and escalating to the supervisor.
Exception that an actor fails with if it does not handle a Terminated message.
Filter which matches Debug events, if they satisfy the given criteria:
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either with String.startsWith or Regex.findFirstIn().isDefined)
If you want to match all Debug events, the most efficient is to use Left("").Used for building a partial function for
Actor.supervisorStrategy().INTERNAL API
INTERNAL API
A lock-less thread-safe implementation of
FailureDetectorRegistry.This resizer resizes the pool to an optimal size that provides
the most message throughput.
Logger for OSGi environment.
INTERNAL API
INTERNAL API
This is the only actual concrete service key type
Provide sigar instance as
SigarProxy with configured location via ClusterMetricsSettings.INTERNAL API
Represents a strategy that decides how to deal with a buffer of time based operator
that is full but is about to receive a new element.
Allows to manage delay and can be stateful to compute delay for any sequence of elements,
all elements go through nextDelay() updating state and returning delay for each element
Allows to manage delay.
param: persistenceId The persistence id of the origin entity.
Delete events in the journal up to
toSeqNumber operation.Reply message to a failed
JournalProtocol.DeleteMessagesTo request.Reply message to a successful
JournalProtocol.DeleteMessagesTo request.Exception thrown when Durable State revision cannot be deleted.
INTERNAL API
Delete particular snapshot from storage by its metadata.
Sent to a
PersistentActor after failed deletion of a snapshot.Delete snapshots from storage by criteria.
Sent to a
PersistentActor after failed deletion of a range of snapshots.Sent to a
PersistentActor after successful deletion of specified range of snapshots.Sent to a
PersistentActor after successful deletion of a snapshot.Not for user extension
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API: Used by the Replicator actor.
ReplicatedData with additional support for delta-CRDT replication.DequeBasedMessageQueue refines QueueBasedMessageQueue to be backed by a java.util.Deque.
Scala API: Mix in DiagnosticActorLogging into your Actor to easily obtain a reference to a logger with MDC support,
which is available under the name "log".
INTERNAL API
INTERNAL API: No-op passivation strategy for when automatic passivation is disabled.
INTERNAL API: No-op passivation strategy for when automatic passivation is disabled.
This Serializer is used when
org.apache.pekko.actor.java-serialization = offINTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Discard the message to
pekko.actor.DeadLetter.Discard the message to
pekko.actor.DeadLetter.INTERNAL API
The event-based
BlockingQueue.Configurator for creating
pekko.dispatch.Dispatcher.DispatcherPrerequisites represents useful contextual pieces when constructing a MessageDispatcher
An
ActorSystem looks up all its thread pools via a Dispatchers instance.Dispatchers are to be defined in configuration to allow for tuning
for different environments.
Not for user extension.
Factories for
DispatcherSelectors which describe which thread pool shall be used to run
the actor to which this configuration is applied.Pekko extension for convenient configuration and use of the
Replicator.Pekko extension for convenient configuration and use of the
Replicator.Pekko extension for convenient configuration and use of the
Replicator.Can be used in
pekko.actor.setup.ActorSystemSetup when starting the pekko.actor.typed.ActorSystem
to replace the default implementation of the DistributedData extension.Extension that starts a
DistributedPubSubMediator actor
with settings defined in config section pekko.cluster.pub-sub.This actor manages a registry of actor references and replicates
the entries to peer actors among all cluster nodes or a group of nodes
tagged with a specific role.
Scala API: Send this message to the mediator and it will reply with an
Int of
the number of subscribers.Reply to
GetTopics.Send this message to the mediator and it will reply with
DistributedPubSubMediator.CurrentTopics containing the names of the (currently known)
registered topic names.INTERNAL API
Messages used to encode protocol to make sure that we do not send Subscribe/Unsubscribe message to
child (mediator -> topic, topic -> group) during a period of transition.
Marker trait for remote messages with special serializer.
*
Defines a remote address.
*
Defines a remote address.
Protobuf type
DeltaProtobuf type
Delta.BucketProtobuf type
Delta.BucketProtobuf type
DeltaProtobuf type
Delta.EntryProtobuf type
Delta.EntryProtobuf type
PayloadProtobuf type
Payload
*
Publish normally local, but it is also used by the ClusterClient.
*
Publish normally local, but it is also used by the ClusterClient.
*
Send normally local, but it is also used by the ClusterClient.
*
Send normally local, but it is also used by the ClusterClient.
*
SendToAll normally local, but it is also used by the ClusterClient.
*
SendToAll normally local, but it is also used by the ClusterClient.
*
Send a message to only one subscriber of a group.
*
Send a message to only one subscriber of a group.
Protobuf type
StatusProtobuf type
StatusProtobuf type
Status.VersionProtobuf type
Status.Versionparam: role Start the mediator on members tagged with this role.
Not for user extension.
INTERNAL API
Supersedes
pekko.io.Dns protocol.Sending this to the
internal.AsyncDnsManager will either lead to a DnsProtocol.Resolved or a pekko.actor.Status.Failure response.param: name of the record
param: records resource records for the query
param: additionalRecords records that relate to the query but are not strictly answers
Supersedes
pekko.io.Dns protocol.Where as it is possible to plug in alternative DNS implementations it is not recommended.
INTERNAL API
INTERNAL API
INTERNAL API
Typically used together with
Future to signal completion
but there is no actual value completed.Marks APIs that are designed under a closed-world assumption for and are NOT meant to be extended
by user-code.
Send command to DOWN the node specified by 'address'.
API for plugins that will handle downing of cluster nodes.
INTERNAL API
INTERNAL API
Envelope that is published on the eventStream wrapped in
pekko.actor.DeadLetter for every message that is
dropped due to overfull queues or routers with no routees.Actor message protocol for storing and confirming reliable delivery of messages.
INTERNAL API
Request that is used at startup to retrieve the unconfirmed messages and current sequence number.
The fact (event) that a message has been sent.
Store the fact that a message has been confirmed to be delivered and processed.
Store the fact that a message is to be sent.
Actor message protocol for storing and confirming reliable delivery of messages.
A
Behavior for a persistent actor with durable storage of its state.Further customization of the
DurableStateBehavior can be done with the methods defined here.The
CommandHandler defines how to act on commands.API May Change
A
DurableStateBehavior that is enforcing that replies to commands are not forgotten.The
DurableStateStoreQuery stream elements for DurableStateStoreQuery.Exception thrown when Durable State cannot be updated or deleted.
INTERNAL API
Supertype for all
DurableStateBehavior specific signalsAPI for reading durable state objects with payload
A.API for reading durable state objects with payload
A.Query API for reading durable state objects.
Query API for reading durable state objects.
INTERNAL API
A DurableStateStore may optionally support this query by implementing this trait.
A DurableStateStore may optionally support this query by implementing this trait.
A durable state store plugin must implement a class that implements this trait.
Query API for reading durable state objects.
Query API for reading durable state objects.
Persistence extension for queries.
API for updating durable state objects.
API for updating durable state objects.
An actor implementing the durable store for the Distributed Data
Replicator
has to implement the protocol with the messages defined here.Wrapper class for serialization of a data value.
Request to load all entries.
Request to store an entry.
An actor implementing the durable store for the Distributed Data
Replicator
has to implement the protocol with the messages defined here.The DynamicAccess implementation is the class which is used for
loading all configurable parts of an actor system (the
pekko.actor.ReflectiveDynamicAccess is the default implementation).see
TLSClosingAll tracked effects for the
pekko.actor.testkit.typed.scaladsl.BehaviorTestKit and
pekko.actor.testkit.typed.javadsl.BehaviorTestKit must extend this type.An executable piece of code that takes no parameters and doesn't return any value.
A command handler returns an
Effect directive that defines what event or events to persist.A command handler returns an
Effect directive that defines what event or events to persist.A command handler returns an
Effect directive that defines what state to persist.A command handler returns an
Effect directive that defines what state to persist.The behavior create a message adapter for the messages of type clazz
Used for NoEffects expectations by type
Used to represent an empty list of effects - in other words, the behavior didn't do anything observable
The behavior set a new receive timeout, with
message as timeout notificationThe behavior used
context.scheduleOnce to schedule message to be sent to target after delay
FIXME what about events scheduled through the scheduler?The behavior spawned a named child with the given behavior (and optionally specific props)
INTERNAL API
Spawning adapters is private[pekko]
The behavior spawned an anonymous child with the given behavior (and optionally specific props)
INTERNAL API
The behavior stopped
childNameThe behavior stopped watching
other, through context.unwatch(other)The behavior started watching
other, through context.watch(other)The behavior started watching
other, through context.watchWith(other, message)Factory methods for creating
Effect directives - how an event sourced actor reacts on a command.Factory methods for creating
Effect directives - how a DurableStateBehavior reacts on a command.A command handler returns an
Effect directive that defines what event or events to persist.A command handler returns an
Effect directive that defines what event or events to persist.A command handler returns an
Effect directive that defines what state to persist.A command handler returns an
Effect directive that defines what state to persist.Factory methods for creating
Effect directives - how an event sourced actor reacts on a command.Factory methods for creating
Effect directives - how a DurableStateBehavior reacts on a command.INTERNAL API: see
class EffectFactoriesINTERNAL API: see
class EffectFactoriesFactories for behavior effects for
BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones.Factories for behavior effects for
BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones.Factories for behavior effects for
BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones.Factories for behavior effects for
BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Defines how the entity should be created.
Defines how the entity should be created.
Parameter to
createBehavior function in Entity.of.Parameter to
createBehavior function in Entity.apply.INTERNAL API
A reference to an sharded Entity, which allows
ActorRef-like usage.A reference to an sharded Entity, which allows
ActorRef-like usage.The key of an entity type, the
name must be unique.The key of an entity type, the
name must be unique.INTERNAL API
Filter which matches Error events, if they satisfy the given criteria:
throwable applies an upper bound on the type of exception contained in the Error event
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either
with String.startsWith or Regex.findFirstIn().isDefined); if the message
itself does not match, the match is retried with the contained Exception’s
message; if both are null, the filter always matches if at
the same time the Exception’s stack trace is empty (this catches
JVM-omitted “fast-throw” exceptions)
If you want to match all Error events, the most efficient is to use Left("").INTERNAL API
INTERNAL API
INTERNAL API: Rough estimate in bytes of some serialized data elements.
INTERNAL API: Rough estimate in bytes of some serialized data elements.
Facility to convert from and to specialised data models, as may be required by specialized persistence Journals.
EventAdapters serves as a per-journal collection of bound event adapters.INTERNAL API
Represents the base type for EventBuses
Internally has an Event type, a Classifier type and a Subscriber type
Java API: See documentation for
pekko.event.EventBus
E is the Event type
S is the Subscriber type
C is the Classifier typeEvent wrapper adding meta data for the events in the result stream of
pekko.persistence.query.scaladsl.EventsByTagQuery query, or similar queries.Event wrapper adding meta data for the events in the result stream of
pekko.persistence.query.typed.scaladsl.EventsBySliceQuery query, or similar queries.Facilities for selectively filtering out expected events from logging so
that you can keep your test run’s console output clean and do not miss real
error messages.
Facilities for selectively filtering out expected events from logging so
that you can keep your test run’s console output clean and do not miss real
error messages.
FunctionalInterface for reacting on events having been persisted
Thrown if a journal rejects an event e.g.
A plugin may optionally support this query by implementing this interface.
A plugin may optionally support this query by implementing this trait.
INTERNAL API
A plugin may optionally support this query by implementing this trait.
A plugin may optionally support this query by implementing this trait.
INTERNAL API
A plugin may optionally support this query by implementing this interface.
A plugin may optionally support this query by implementing this trait.
INTERNAL API
INTERNAL API
INTERNAL API.
INTERNAL API: does not force the actor to stash commands; Originates from either `persistAsync` or `defer` calls
INTERNAL API
INTERNAL API: message used to detect that recovery timed out
INTERNAL API: forces actor to stash incoming commands until all these invocations are handled
INTERNAL API
Further customization of the
EventSourcedBehavior can be done with the methods defined here.The
CommandHandler defines how to act on commands.The result of running a command.
The result of running a command.
The result of running a command with a
ActorRef replyTo , i.e.The result of running a command with a
replyTo: ActorRef[R], i.e.The result of restarting the behavior.
The result of restarting the behavior.
Customization of which serialization checks that are performed.
Customization of which serialization checks that are performed.
Testing of
pekko.persistence.typed.javadsl.EventSourcedBehavior implementations.Testing of
pekko.persistence.typed.scaladsl.EventSourcedBehavior implementations.INTERNAL API
A
EventSourcedBehavior that is enforcing that replies to commands are not forgotten.INTERNAL API
pekko.actor.typed.delivery.DurableProducerQueue that can be used with pekko.actor.typed.delivery.ProducerController
for reliable delivery of messages.INTERNAL API
INTERNAL API
INTERNAL API
Supertype for all Pekko Persistence Typed specific signals
INTERNAL API
An Apache Pekko EventStream is a pub-sub stream of events both system and user generated,
where subscribers are ActorRefs and the channels are Classes and Events are any java.lang.Object.
The set of commands accepted by the
pekko.actor.typed.ActorSystem.eventStream.Publish an event of type E by sending this command to
the
pekko.actor.typed.ActorSystem.eventStream.Subscribe a typed actor to listen for types or subtypes of E
by sending this command to the
pekko.actor.typed.ActorSystem.eventStream.Unsubscribe an actor ref from the event stream
by sending this command to the
pekko.actor.typed.ActorSystem.eventStream.INTERNAL API
Encapsulates the
pekko.actor.ActorSystem.eventStream in a BehaviorINTERNAL API
Encapsulates the
pekko.actor.ActorSystem.eventStream in a BehaviorINTERNAL API
EventsBySliceQuery that is using a timestamp based offset should also implement this query.EventsBySliceQuery that is using a timestamp based offset should also implement this query.The exponentially weighted moving average (EWMA) approach captures short-term
movements in volatility for a conditional volatility forecasting model.
ExecutionContexts is the Java API for ExecutionContexts
ExecutionContexts is the Java API for ExecutionContexts
An ExecutorServiceConfigurator is a class that given some prerequisites and a configuration can create instances of ExecutorService
As the name says
This object contains implementation details of the “ask” pattern,
which can be combined with "replyTo" pattern.
For testing: scheduler that does not look at the clock, but must be
progressed manually by calling
timePasses.More powerful interface to the actor system’s implementation which is presented to extensions (see
pekko.actor.Extension).Not for user extension
Extension point for implementing custom behaviors in addition to the existing
set of behaviors available through the DSLs in
pekko.actor.typed.scaladsl.Behaviors and pekko.actor.typed.javadsl.BehaviorsThe basic ActorSystem covers all that is needed for locally running actors,
using futures and so on.
Marker trait/interface for extensions.
Identifies an Extension
Lookup of Extensions is done by object identity, so the Id must be the same wherever it's used,
otherwise you'll get the same extension loaded multiple times.
Identifier and factory for an extension.
To be able to load an ExtensionId from the configuration,
a class that implements ExtensionIdProvider must be specified.
API for registering and looking up extensions.
Each extension typically provide a concrete
ExtensionSetup that can be used in
pekko.actor.setup.ActorSystemSetup when starting the ActorSystem to replace the default
implementation of the extension.INTERNAL API
API May Change
API May Change
API May Change
A failure detector must be a thread-safe mutable construct that registers heartbeat events of a resource and is able to
decide the availability of that monitored resource.
Abstraction of a clock that returns time in milliseconds.
INTERNAL API
INTERNAL API
Interface for a registry of Pekko failure detectors.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Java API: Factories to create sinks and sources from files
Factories to create sinks and sources from files
Java API: Factories to create sinks and sources from files
Factories to create sinks and sources from files
INTERNAL API
INTERNAL API: Adds support for serializing and deserializing
FiniteDuration.INTERNAL API
Not for user extension.
INTERNAL API
INTERNAL API
A
Flow is a set of stream processing steps that has one open input and one open output.A
Flow is a set of stream processing steps that has one open input and one open output.Used to monitor the state of a stream
Stream failed
Stream completed successfully
Stream was created, but no events have passed through it
Stream processed a message
Scala API: Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.
INTERNAL API: this trait will be changed in binary-incompatible ways for classes that are derived from it!
Do not implement this interface outside the Pekko code base!
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).A flow that provides operations which automatically propagate the context of an element.
A flow that provides operations which automatically propagate the context of an element.
Shared stream operations for
FlowWithContext and SourceWithContext that automatically propagate a context
element with each data element.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL PEKKO USAGE ONLY
INTERNAL PEKKO USAGE ONLY
Determines mode in which [[Framing]] operates.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Java API: Wraps a
pekko.actor.Props to mark the actor as externally configurable to be used with a router.Wraps a
pekko.actor.Props to mark the actor as externally configurable to be used with a router.Finite State Machine actor trait.
This extractor is just convenience for matching a (S, S) pair, including a
reminder what the new state is.
Message type which is sent directly to the subscribed actor in
pekko.actor.FSM.SubscribeTransitionCallBack before sending any
pekko.actor.FSM.Transition messages.All messages sent to the
pekko.actor.FSM will be wrapped inside an
Event, which allows pattern matching to extract both state and data.Signifies that the
pekko.actor.FSM is shutting itself down because of
an error, e.g.INTERNAL API
INTERNAL API
Log Entry of the
pekko.actor.LoggingFSM, can be obtained by calling getLog.Default reason if calling
stop().A partial function value which does not match anything and can be used to
“reset”
whenUnhandled and onTermination handlers.Reason why this
pekko.actor.FSM is shutting down.Reason given when someone was calling
system.stop(fsm) from outside;
also applies to Stop supervision directive.INTERNAL API
Using a subclass for binary compatibility reasons
INTERNAL API
This captures all of the managed state of the
pekko.actor.FSM: the state
name, the state data, possibly custom timeout, stop reason and replies
accumulated while processing the last message.This case object is received in case of a state timeout.
Case class representing the state of the
pekko.actor.FSM within the
onTermination block.Send this to an
pekko.actor.FSM to request first the FSM.CurrentState
and then a series of FSM.Transition updates.INTERNAL API
INTERNAL API
Message type which is used to communicate transitions between states to
all subscribed listeners (use
pekko.actor.FSM.SubscribeTransitionCallBack).Unsubscribe from
pekko.actor.FSM.Transition notifications which was
effected by sending the corresponding pekko.actor.FSM.SubscribeTransitionCallBack.Builder used to create a partial function for
FSM.whenUnhandled(scala.PartialFunction<org.apache.pekko.actor.FSM.Event<D>, org.apache.pekko.actor.FSM.State<S, D>>).Deprecated.
use EventSourcedBehavior since Akka 2.6.0
Builder used to create a partial function for
FSM.onTermination(scala.PartialFunction<org.apache.pekko.actor.FSM.StopEvent<S, D>, scala.runtime.BoxedUnit>).Deprecated.
use EventSourcedBehavior since Akka 2.6.0
Builder used to create a partial function for
FSM.onTransition(scala.PartialFunction<scala.Tuple2<S, S>, scala.runtime.BoxedUnit>).A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
A Function interface.
INTERNAL API
INTERNAL API
INTERNAL API
A combination of a Future and an ActorRef associated with it, which points
to an actor performing a task which will eventually resolve the Future.
Futures is the Java API for Futures and Promises
Futures is the Java API for Futures and Promises
Get the cluster clients known to this receptionist.
Query the statistics about the currently running sharded entities in the
entire cluster.
Get the contact points known to this client.
Sending this message to a router will make it send back its currently used routees.
Query the ShardRegion state for the given entity type key.
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Not intended to be directly extended by user classes
Scala API, see https://github.com/akka/akka/issues/28501 for discussion why this can't be an instance method on class Graph.
A GraphStage represents a reusable graph stream processing operator.
Represents the processing logic behind a
GraphStage.Input handler that terminates the state upon receiving completion if the
given condition holds at that time.
Output handler that terminates the state upon receiving completion if the
given condition holds at that time.
Input handler that terminates the operator upon receiving completion.
Output handler that terminates the operator upon cancellation.
Input handler that does not terminate the operator upon receiving completion.
Output handler that does not terminate the operator upon cancellation.
Minimal actor to work with other actors and watch them in a synchronous ways
Input handler that does not terminate the operator upon receiving completion
nor failure.
Java API:
GraphStageLogic with StageLogging.Messages emitted after the corresponding
stageUnderTest methods has been invoked.Sent to the probe when the operator callback threw an exception
param: operation The operation that failed
Messages emitted after the corresponding
stageUnderTest methods has been invoked.Scala API: A GraphStage represents a reusable graph stream processing operator.
RouterConfig for router actor with routee actors that are created external to the
router and the router sends messages to the specified path using actor selection,
without watching for termination.Java API: Base class for custom router
GroupProvides builder style configuration options for group routers
Provides builder style configuration options for group routers
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Set of methods which allow easy implementation of
hashCode.Set of methods which allow easy implementation of
hashCode.Default message extractor type, using envelopes to identify what entity a message is for
and the hashcode of the entityId to decide which shard an entity belongs to.
Default message extractor type, using a property of the message to identify what entity a message is for
and the hashcode of the entityId to decide which shard an entity belongs to.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Abstract persistent storage for tests.
INTERNAL API
INTERNAL API
MetricsSelector that uses the heap metrics.
MetricsSelector that uses the heap metrics.
Failure detector heartbeat messages are marked with this trait.
Implicit class providing
requiring methods.INTERNAL API
A message all Actors will understand, that when processed will reply with
pekko.actor.ActorIdentity containing the ActorRef.No-op model adapter which passes through the incoming events as-is.
No-op model adapter which passes through the incoming events as-is.
INTERNAL API
INTERNAL API
INTERNAL API
see
TLSClosingsee
TLSClosingsee
TLSClosingIllegalActorStateException is thrown when a core invariant in the Actor implementation has been violated.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Decompress and cause compression advertisements.
INTERNAL API
Inbound API that is used by the stream operators.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
An implementation of a ConcurrentMultiMap
Adds/remove is serialized over the specified key
Reads are fully concurrent <-- el-cheapo
This interface defines a class of actor creation strategies deviating from
the usual default of just reflectively instantiating the
Actor
subclass.Java API: AbstractSocketOption is a package of data (from the user) and associated
behavior (how to apply that to a channel).
Java API
DatagramChannel creation behavior.
SocketOption is a package of data (from the user) and associated
behavior (how to apply that to a channel).
INTERNAL API
INTERNAL API
Filter which matches Info events, if they satisfy the given criteria:
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either with String.startsWith or Regex.findFirstIn().isDefined)
If you want to match all Info events, the most efficient is to use Left("").Collection of callbacks for an input port of a
GraphStageINTERNAL API
An Inlet is a typed input to a Shape.
The InmemJournal publishes writes and deletes to the
eventStream, which tests may use to
verify that expected events have been persisted or deleted.INTERNAL API.
INTERNAL API
INTERNAL API
INTERNAL API
An input port of a StreamLayout.Module.
Provides the impl of any behavior that could nest another behavior
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.
INTERNAL API
Marks APIs that are considered internal to Apache Pekko and may change at any point in time
without any warning.
INTERNAL API
Command to
pekko.cluster.ClusterDaemon to create a
pekko.cluster.OnMemberStatusChangedListener.Node with version 2.5.9 or earlier is joining.
see JoinSeedNode
see JoinSeedNode
see JoinSeedNode
Command to join the cluster.
Start message of the process to join one of the seed nodes.
Command to initiate the process to join the specified
seed nodes.
param: receiver
pekko.cluster.ClusterEvent.CurrentClusterState will be sent to the receiverMarker interface for periodic tick messages
Reply to Join
INTERNAL API
A marker trait for internal messages.
Protocol used internally by the eventsourced behaviors.
Protocol used internally by the DurableStateBehavior.
INTERNAL API
INTERNAL API
Marks APIs that are considered internal to Apache Pekko and should not be accessed by user code
but that are used across Apache Pekko project boundaries and therefore shouldn't be changed
without considering possible usage outside of the Apache Pekko core modules.
A snapshot of one interpreter - contains a set of logics running in the same underlying actor.
An InvalidActorNameException is thrown when you try to convert something, usually a String, to an Actor name
which doesn't validate.
InvalidMessageException is thrown when an invalid message is sent to an Actor;
Currently only
null is an invalid message.Stream refs establish a connection between a local and remote actor, representing the origin and remote sides
of a stream.
Entry point to Akka’s IO layer.
Entry point to Akka’s IO layer.
This exception signals that a stream has been completed or has an error while
there was still IO operations in progress
Holds a result of an IO operation.
INTERNAL API
INTERNAL API
Data migration of old formats to current format can
be implemented in a concrete subclass and configured to
be used by the
JacksonSerializer for a changed class.INTERNAL API
INTERNAL API
Used with
JacksonObjectMapperProviderSetup for defining a JacksonObjectMapperProvider that can be
passed in when ActorSystem is created rather than creating one from configured class name.Registry of shared
ObjectMapper instances, each with its unique bindingName.Setup for defining a
JacksonObjectMapperProvider that can be passed in when ActorSystem
is created rather than creating one from configured class name.INTERNAL API
Provides support for `java.util.concurrent.Flow.*` interfaces which mirror the Reactive Streams
interfaces from `org.reactivestreams`.
Provides support for
java.util.concurrent.Flow.* interfaces which mirror the Reactive Streams
interfaces from org.reactivestreams.{@link org.apache.pekko.stream.javadsl.Flow]] factories operating with
java.util.concurrent.Flow.* interfaces.pekko.stream.scaladsl.Flow factories operating with java.util.concurrent.Flow.* interfaces.Sink factories operating with
java.util.concurrent.Flow.* interfaces.pekko.stream.scaladsl.Sink factories operating with java.util.concurrent.Flow.* interfaces.{@link org.apache.pekko.stream.javadsl.Flow]] factories operating with
java.util.concurrent.Flow.* interfaces.pekko.stream.scaladsl.Source factories operating with java.util.concurrent.Flow.* interfaces.Provides support for
java.util.concurrent.Flow.* interfaces which mirror the Reactive Streams
interfaces from org.reactivestreams.JAVA API
JAVA API
Helper for implementing a *pure* partial function: it will possibly be
invoked multiple times for a single “application”, because its only abstract
method is used for both isDefinedAt() and apply(); the former is mapped to
isCheck == true and the latter to isCheck == false for those cases where
this is important to know.Marker trait for test messages that will use Java serialization via
TestJavaSerializerThis Serializer uses standard Java Serialization
JAVA API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Loads JVM and system metrics through JMX monitoring beans.
Try to join this cluster node with the node specified by 'address'.
INTERNAL API
INTERNAL API
INTERNAL API
Scala API: Join the specified seed nodes without defining them in config.
INTERNAL API
INTERNAL API
INTERNAL API
This spec measures execution times of the basic operations that an
pekko.persistence.PersistentActor provides,
using the provided Journal (plugin).INTERNAL API.
Request to delete all persistent messages with sequence numbers up to
toSequenceNr
(inclusive).Reply message to a
JournalProtocol.WriteMessages with a non-persistent message.Marker trait shared by internal journal messages.
Reply message to a successful
JournalProtocol.ReplayMessages request.Reply message to a
JournalProtocol.ReplayMessages request.Request to replay messages to
persistentActor.Reply message to a failed
JournalProtocol.ReplayMessages request.Internal journal command.
Internal journal acknowledgement.
Reply message to a failed
JournalProtocol.WriteMessages request.Reply message to a rejected
JournalProtocol.WriteMessages request.Request to write messages.
Reply message to a failed
JournalProtocol.WriteMessages request.Reply message to a successful
JournalProtocol.WriteMessages request.Reply message to a successful
JournalProtocol.WriteMessages request.INTERNAL API.
This spec aims to verify custom pekko-persistence Journal implementations.
Java API for creating a Serializer: make sure to include a constructor which
takes exactly one argument of type
pekko.actor.ExtendedActorSystem, because
that is the preferred constructor which will be invoked when reflectively instantiating
the JSerializer (also possible with empty constructor).Provides JSON framing operators that can separate valid JSON objects from incoming
pekko.util.ByteString objects.Provides JSON framing operators that can separate valid JSON objects from incoming
pekko.util.ByteString objects.Thrown if upstream completes with a partial object in the buffer.
Provides JSON framing operators that can separate valid JSON objects from incoming
pekko.util.ByteString objects.Provides JSON framing operators that can separate valid JSON objects from incoming
pekko.util.ByteString objects.Convenience functions for often-encountered purposes like keeping only the
left (first) or only the right (second) of two input values.
Convenience functions for often-encountered purposes like keeping only the
left (first) or only the right (second) of two input values.
Key for the key-value data in
Replicator.A message all Actors will understand, that when processed will make the Actor throw an ActorKilledException,
which will trigger supervision.
A
KillSwitch allows completion of Graphs from the outside by completing Graphs of FlowShape linked
to the switch.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.
INTERNAL API
Send command to issue state transition to LEAVING for the node specified by 'address'.
INTERNAL API.
INTERNAL API.
INTERNAL API.
Deprecated.
Use another journal implementation.
Deprecated.
Use another journal implementation.
Deprecated.
Use another journal/query implementation.
INTERNAL API.
INTERNAL API.
This scheduler implementation is based on a revolving wheel of buckets,
like Netty’s HashedWheelTimer, which it advances at a fixed tick rate and
dispatches tasks it finds in the current bucket to their respective
ExecutionContexts.
INTERNAL API
INTERNAL API
This is a minimized byte-code parser that concentrates exclusively on line
numbers and source file extraction.
This is a minimized byte-code parser that concentrates exclusively on line
numbers and source file extraction.
Listeners is a generic trait to implement listening capability on an Actor.
EventsBySliceQuery that is using a timestamp based offset should also implement this query.EventsBySliceQuery that is using a timestamp based offset should also implement this query.INTERNAL API
INTERNAL API
Refs which are statically known to be local inherit from this Scope
The Local Scope is the default one, which is assumed on all deployments
which do not set a different scope.
INTERNAL API
INTERNAL API
JUnit
TestRule to make log lines appear only when the test failed.Mixin this trait to a ScalaTest test to make log lines appear only when the test failed.
Logger is a factory for obtaining SLF4J-Loggers
Logger is a factory for obtaining SLF4J-Loggers
INTERNAL API
INTERNAL API
Artificial exception injected into Error events if no Throwable is
supplied; used for getting a stack dump of error locations.
This trait brings log level handling to the EventStream: it reads the log
levels for the initial logging (StandardOutLogger) and the loggers & level
for after-init logging, possibly keeping the StandardOutLogger enabled if
it is part of the configured loggers.
Stackable trait for
pekko.actor.FSM which adds a rolling event log and
debug logging capabilities (analogous to pekko.event.LoggingReceive).Deprecated.
Use EventSourcedBehavior.
This decorator adds invocation logging to a Receive function.
Facilities for verifying logs.
Facilities for verifying logs.
Facilities for selectively matching log messages.
Facilities for selectively matching expected events from logging.
INTERNAL API
Not for user extension
DO NOT INHERIT: Class is open only for use by pekko-slf4j
INTERNAL API
INTERNAL API
Logging options when using
Behaviors.logMessages.Factories for log options
A service lookup.
Maps Subscribers to Classifiers using equality on Classifier to store a Set of Subscribers (hence the need for compareSubscribers)
Maps Events to Classifiers through the classify-method (so it knows who to publish to)
Java API: See documentation for
pekko.event.LookupClassification
E is the Event type
S is the Subscriber type
C is the Classifier typeSpecialized
ORMap with LWWRegister values.INTERNAL API
Implements a 'Last Writer Wins Register' CRDT, also called a 'LWW-Register'.
Utility class for comparing timestamp replica
identifier when implementing last-writer wins.
INTERNAL API
Not for user extension.
MailboxType is a factory to create MessageQueues for an optionally
provided ActorContext.
Maps ActorRefs to ActorRefs to form an EventBus where ActorRefs can listen to other ActorRefs.
Java API: See documentation for
pekko.event.ManagedActorClassification
An EventBus where the Subscribers are ActorRefs and the Classifier is ActorRef
Means that ActorRefs "listen" to other ActorRefs
E is the Event typeUtility that extracts
ManifestInfo#Version information from META-INF/MANIFEST.MF in jar files on the classpath.Comparable version information
Apache Pekko extension that extracts
ManifestInfo.Version information from META-INF/MANIFEST.MF in jar files
on the classpath of the ClassLoader of the ActorSystem.Not for user instantiation, see
ManualTime.get(org.apache.pekko.actor.typed.ActorSystem<A>)Not for user instantiation, see
ManualTime.apply(org.apache.pekko.actor.typed.ActorSystem<?>)Manual time allows you to do async tests while controlling the scheduler of the system.
Manual time allows you to do async tests while controlling the scheduler of the system.
Internal API
LoggingAdapter extension which adds Marker support.Version of
PartialFunction that can be built during runtime from Java.This exception or subtypes thereof should be used to signal materialization
failures.
The Materializer is the component responsible for turning a stream blueprint into a running stream.
Not for user extension
Debug utility to dump the running streams of a materializers in a structure describing the graph layout
and "waits-on" relationships.
Debug utility to dump the running streams of a materializers in a structure describing the graph layout
and "waits-on" relationships.
Represents the address, current status, and roles of a cluster member node.
Module with factory and ordering methods for Member instances.
INTERNAL API
Defines the current status of a cluster member node
Merge several streams, taking elements as they arrive from input streams
(picking randomly when several have elements ready).
Merge several streams, taking elements as they arrive from input streams
(picking randomly when several have elements ready).
Merge several streams, taking elements as they arrive from input streams
(picking randomly when several have elements ready).
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of
producers.
A DrainingControl object is created during the materialization of a MergeHub and allows to initiate the draining
and eventual completion of the Hub from the outside.
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of
producers.
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of
producers.
MergeLatest joins elements from N input streams into stream of lists of size N.
MergeLatest joins elements from N input streams into stream of lists of size N.
MergeLatest joins elements from N input streams into stream of lists of size N.
Merge several streams, taking elements as they arrive from input streams
(picking from preferred when several have elements ready).
Merge several streams, taking elements as they arrive from input streams
(picking from preferred when several have elements ready).
Merge several streams, taking elements as they arrive from input streams
(picking from preferred when several have elements ready).
Merge several streams, taking elements as they arrive from input streams
(picking from prioritized once when several have elements ready).
Merge several streams, taking elements as they arrive from input streams
(picking from prioritized once when several have elements ready).
Merge several streams, taking elements as they arrive from input streams
(picking from prioritized once when several have elements ready).
Takes multiple streams whose elements in aggregate have a defined linear
sequence with difference 1, starting at 0, and outputs a single stream
containing these elements, in order.
Takes multiple streams whose elements in aggregate have a defined linear
sequence with difference 1, starting at 0, and outputs a single stream
containing these elements, in order.
Takes multiple streams whose elements in aggregate have a defined linear
sequence with difference 1, starting at 0, and outputs a single stream
containing these elements, in order.
Merge two pre-sorted streams such that the resulting stream is sorted.
Merge two pre-sorted streams such that the resulting stream is sorted.
Merge two pre-sorted streams such that the resulting stream is sorted.
Marker trait for all protobuf-serializable messages in
pekko.persistence.INTERNAL API
Signal passed to the actor when a message adapter has thrown an exception adapting an incoming message.
A non thread safe mutable message buffer that can be used to buffer messages inside actors.
A non thread safe mutable message buffer map that can be used to buffer messages inside actors.
INTERNAL API
Base class to be used for hooking in new dispatchers into Dispatchers.
INTERNAL API
Protobuf type
AtLeastOnceDeliverySnapshotProtobuf type
AtLeastOnceDeliverySnapshotProtobuf type
AtLeastOnceDeliverySnapshot.UnconfirmedDeliveryProtobuf type
AtLeastOnceDeliverySnapshot.UnconfirmedDeliveryProtobuf type
AtomicWriteProtobuf type
AtomicWriteProtobuf type
PersistentFSMSnapshotProtobuf type
PersistentFSMSnapshotProtobuf type
PersistentMessageProtobuf type
PersistentMessageProtobuf type
PersistentPayloadProtobuf type
PersistentPayloadProtobuf type
PersistentStateChangeEventProtobuf type
PersistentStateChangeEventA MessageQueue is one of the core components in forming an Akka Mailbox.
Protobuf serializer for
pekko.cluster.metrics.ClusterMetricsMessage types.Protobuf serializer for
pekko.persistence.PersistentRepr, pekko.persistence.AtLeastOnceDelivery and pekko.persistence.fsm.PersistentFSM.StateChangeEvent messages.INTERNAL API
INTERNAL API
Metrics key/value.
Factory for creating valid Metric instances.
INTERNAL API
Metrics sampler.
INTERNAL API
INTERNAL API
A MetricsSelector is responsible for producing weights from the node metrics.
Trait for ActorRef implementations where all methods contain default stubs.
Singleton instance of the default MixMetricsSelector, which uses [org.apache.pekko.cluster.routing.HeapMetricsSelector],
[org.apache.pekko.cluster.routing.CpuMetricsSelector], and [org.apache.pekko.cluster.routing.SystemLoadAverageMetricsSelector]
Base class for MetricsSelector that combines other selectors and aggregates their capacity.
Configure the role names and participants of the test, including configuration settings.
Note: To be able to run tests with everything ignored or excluded by tags
you must not use
testconductor, or helper methods that use testconductor,
from the constructor of your test class.Use this to hook MultiNodeSpec into your test framework lifecycle, either by having your test extend MultiNodeSpec
and call these methods or by creating a trait that calls them and then mixing that trait with your test together
with MultiNodeSpec.
This is a marker trait for message queues which support multiple consumers,
as is required by the BalancingDispatcher.
INTERNAL API
INTERNAL API
The murmur2 message extractor uses the same algorithm as the default kafka partitioner
allowing kafka partitions to be mapped to shards.
An object designed to generate well-distributed non-cryptographic
hashes.
An object designed to generate well-distributed non-cryptographic
hashes.
Default implementation of
TokenBucket that uses System.nanoTime as the time source.INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
This is an internal look-up failure token, not useful for anything else.
This is an internal look-up failure token, not useful for anything else.
The snapshot of current sampled health metrics for any monitored process.
Default downing provider used when no provider is configured.
INTERNAL API
INTERNAL API
NoLogging is a LoggingAdapter that does absolutely nothing – no logging at all.
NoLogging is a LoggingAdapter that does absolutely nothing – no logging at all.
NoLogging is a MarkerLoggingAdapter that does absolutely nothing – no logging at all.
NoLogging is a MarkerLoggingAdapter that does absolutely nothing – no logging at all.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
NonBlockingBoundedMailbox is a high-performance, multiple-producer single-consumer, bounded MailboxType,
Noteworthy is that it discards overflow as DeadLetters.
Used when retrieving all events.
Used when retrieving all events.
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
INTERNAL API
INTERNAL API
INTERNAL API
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
This verifier approves all sessions.
This verifier approves all sessions.
INTERNAL
INTERNAL
INTERNAL API
INTERNAL API
Routee that doesn't send the message to any routee.Routee that doesn't send the message to any routee.Routing configuration that indicates no routing; this is also the default
value which hence overrides the merge strategy in order to accept values
from lower-precedence sources.
This is the default value and as such allows overrides.
Marker trait to signal that this class should not be verified for serializability.
Used as default snapshot-store in case no other store was configured.
INTERNAL API
Marker trait to indicate that a message should not reset the receive timeout.
This type is used in generic type signatures wherever the actual value is of no importance.
This is a special Serializer that Serializes and deserializes nulls only
Applies the fault handling
Directive (Resume, Restart, Stop) specified in the Decider
to the child actor that failed, as opposed to pekko.actor.AllForOneStrategy that applies
it to all children.Mix in this trait to suppress the StackTrace for the instance of the exception but not the cause,
scala.util.control.NoStackTrace suppresses all the StackTraces.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
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.
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.
This is an extractor for retrieving the original cause (i.e.
This is an extractor for retrieving the original cause (i.e.
An immutable multi-map implementation.
INTERNAL API
INTERNAL API
Implements a 'Observed Remove Set' operation based CRDT, also called a 'OR-Set'.
Factory class to create ActorSystem implementations in an OSGi environment.
INTERNAL API
Outbound association API that is used by the stream operators.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Collection of callbacks for an output port of a
GraphStageAn Outlet is a typed output to a Shape.
An output port of a StreamLayout.Module.
INTERNAL API
Represents a strategy that decides how to deal with a buffer that is full but is
about to receive a new element.
A ReadJournal may optionally support this query by implementing this trait.
A plugin ReadJournal may optionally support this query by implementing this trait.
Java API
Represents a pair (tuple) of two elements.
Fan-out the stream to several streams.
Fan-out the stream to several streams.
Fan-out the stream to several streams.
A
PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers.A
PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers.A
PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers.Pekko base Exception.
Complete module with support for all custom serializers.
INTERNAL API
Trait that represents decoded Pekko PDUs (Protocol Data Units)
INTERNAL API
INTERNAL API
INTERNAL API
Decodes lax PEM encoded data, according to
Decodes lax PEM encoded data, according to
INTERNAL API
INTERNAL API
INTERNAL API: Support trait allowing trivially recording perf metrics from
MultiNodeSpecsPersistence extension.
Persistence extension provider.
Unique identifier in the backend data store (journal and snapshot store) of the
persistent actor.
Identification of
PersistentActor.A plugin may optionally support this query by implementing this interface.
A plugin may optionally support this query by implementing this trait.
Test utility to initialize persistence plugins.
Test utility to initialize persistence plugins.
Test utility to initialize persistence plugins.
Test utility to initialize persistence plugins.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
PersistencePluginProxyExtensionImpl is an
Extension that enables initialization of the PersistencePluginProxy
via configuration, without requiring any code changes or the creation of any actors.Persistence extension for queries.
Persistence configuration.
Class for testing persisted events in persistent actors.
Class for testing events of persistent actors.
INTERNAL API
INTERNAL API
Scala API: A persistent Actor - can be used to implement command or Event Sourcing.
INTERNAL API
Deprecated.
Use EventSourcedBehavior.
This extractor is just convenience for matching a (S, S) pair, including a
reminder what the new state is.
Message type which is sent directly to the subscribed actor in
pekko.actor.FSM.SubscribeTransitionCallBack before sending any
pekko.actor.FSM.Transition messages.All messages sent to the
pekko.actor.FSM will be wrapped inside an
Event, which allows pattern matching to extract both state and data.Signifies that the
pekko.actor.FSM is shutting itself down because of
an error, e.g.INTERNAL API
INTERNAL API
FSMState base trait, makes possible for simple default serialization by conversion to String
Log Entry of the
pekko.actor.LoggingFSM, can be obtained by calling getLog.Default reason if calling
stop().A partial function value which does not match anything and can be used to
“reset”
whenUnhandled and onTermination handlers.Base persistent event class
FSM state and data snapshot
Reason why this
pekko.actor.FSM is shutting down.Reason given when someone was calling
system.stop(fsm) from outside;
also applies to Stop supervision directive.INTERNAL API
This captures all of the managed state of the
pekko.actor.FSM: the state
name, the state data, possibly custom timeout, stop reason, replies
accumulated while processing the last message, possibly domain event and handler
to be executed after FSM moves to the new state (also triggered when staying in the same state)Persisted on state change
Not deprecated as used for users migrating from PersistentFSM to EventSourcedBehavior
This case object is received in case of a state timeout.
Case class representing the state of the
pekko.actor.FSM whithin the
onTermination block.Send this to an
pekko.actor.FSM to request first the PersistentFSM.CurrentState
and then a series of PersistentFSM.Transition updates.INTERNAL API
INTERNAL API
INTERNAL API
Message type which is used to communicate transitions between states to
all subscribed listeners (use
pekko.actor.FSM.SubscribeTransitionCallBack).Unsubscribe from
pekko.actor.FSM.Transition notifications which was
effected by sending the corresponding pekko.actor.FSM.SubscribeTransitionCallBack.Deprecated.
Use EventSourcedBehavior.
Deprecated.
Use EventSourcedBehavior.
Helper functions for migration from PersistentFSM to Persistence Typed
Helper functions for migration from PersistentFSM to Persistence Typed
Helper functions for migration from PersistentFSM to Persistence Typed
Helper functions for migration from PersistentFSM to Persistence Typed
Plugin API: representation of a persistent message in the journal plugin API.
Singleton coordinator that decides where to allocate shards.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
A builder for
PartialFunction.Implementation of 'The Phi Accrual Failure Detector' by Hayashibara et al.
Dedicates a unique thread for each actor passed in as reference.
Configurator for creating
pekko.dispatch.PinnedDispatcher.INTERNAL API
INTERNAL API
The Player is the client component of the
pekko.remote.testconductor.TestConductorExt extension.INTERNAL API
Implements a 'Increment/Decrement Counter' CRDT, also called a 'PN-Counter'.
Map of named counters.
INTERNAL API
A message all Actors will understand, that when processed will terminate the Actor permanently.
INTERNAL API
INTERNAL API
RouterConfig for router actor that creates routees as child actors and removes
them from the router if they terminate.Java API: Base class for custom router
PoolINTERNAL API
Provides builder style configuration options for pool routers
Provides builder style configuration options for pool routers
INTERNAL API
Marker trait to indicate that a message might be potentially harmful,
this is used to block messages coming in over remoting.
A PostRestartException is thrown when constructor or postRestart() method
fails during a restart attempt.
Lifecycle signal that is fired after this actor and all its child actors
(transitively) have terminated.
Lifecycle signal that is fired after this actor and all its child actors
(transitively) have terminated.
Java API: Defines a criteria and determines whether the parameter meets this criteria.
Java API: Defines a criteria and determines whether the parameter meets this criteria.
Can be mixed into an EventBus to specify that the Classifier type is a Function from Event to Boolean (predicate)
Initiate a full cluster shutdown.
Lifecycle signal that is fired upon restart of the Actor before replacing
the behavior with the fresh one (i.e.
A PreRestartException is thrown when the preRestart() method failed; this
exception is not propagated to the supervisor, as it originates from the
already failed instance, hence it is only visible as log entry on the event
stream.
INTERNAL API
INTERNAL API
A PriorityGenerator is a convenience API to create a Comparator that orders the messages of a
PriorityDispatcher
INTERNAL API
Messages marked with this trait will be sent before other messages when buffering is active.
PriorityQueueStabilizer wraps a priority queue so that it respects FIFO for elements of equal priority.
A Procedure is like a Function, but it doesn't produce a return value.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
A Consumer interface.
Policies allow to emulate behavior of the storage (failures and rejections).
INTERNAL API
INTERNAL API
INTERNAL API
Emulates successful processing of some operation.
Point-to-point reliable delivery between a single producer actor sending messages and a single consumer
actor receiving the messages.
For sending confirmation message back to the producer when the message has been confirmed.
Register the given
consumerController to the ProducerController.The
ProducerController sends RequestNext to the producer when it is allowed to send one
message via the sendNextTo or askNextTo.Initial message from the producer actor.
Point-to-point reliable delivery between a single producer actor sending messages and a single consumer
actor receiving the messages.
For commands defined in public ProducerController
INTERNAL API
INTERNAL API
Used to determine mailbox factories which create
BoundedMessageQueueSemantics
mailboxes, and thus should be validated that the pushTimeOut is greater than 0.INTERNAL API
A combination of a Promise and an ActorRef associated with it, which points
to an actor performing a task which will eventually resolve the Promise.
Data structure for describing an actor’s props details like which
executor to run it on.
Factory for Props instances.
INTERNAL API
Wrap
pekko.actor.typed.Behavior in a classic pekko.actor.Props, i.e.INTERNAL API
Wrap
pekko.actor.typed.Behavior in a classic pekko.actor.Props, i.e.INTERNAL API
The empty configuration node, used as a terminator for the internally linked
list of each Props.
INTERNAL API
This Serializer serializes
org.apache.pekko.protobufv3.internal.Message
It is using reflection to find the parseFrom and toByteArray methods to avoid
dependency to com.google.protobuf.INTERNAL API.
INTERNAL API.
INTERNAL API.
INTERNAL API
INTERNAL API
When using event publishing the events published to the system event stream will be in this form.
Sources and sinks to integrate
pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.Sources and sinks to integrate
pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.Sources and sinks to integrate
pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.Sources and sinks to integrate
pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.Deprecated.
Classic remoting is deprecated, use Artery.
for org.apache.pekko.persistence.query.typed.EventEnvelope
for org.apache.pekko.persistence.query.typed.EventEnvelope
INTERNAL API
A QueueBasedMessageQueue is a MessageQueue backed by a java.util.Queue.
Not for user extension
Not for user extension
Type is used to indicate that stream is dropped an element
Type is used to indicate that stream is successfully enqueued an element
Type is used to indicate that stream is failed before or during call to the stream
param: cause - exception that stream failed with
Type is used to indicate that stream is completed before call
Contains types that is used as return types for streams Source queues
A
QueueSelector is responsible for, given a Runnable and the number of available
queues, return which of the queues that Runnable should be placed in.A router group that randomly selects one of the target routees to send a message to.
A router pool that randomly selects one of the target routees to send a message to.
Randomly selects one of the target routees to send a message to
INTERNAL API
Exception that is thrown when rated controlled by stream is exceeded
INTERNAL API
INTERNAL API
Facility to convert from and to specialised data models, as may be required by specialized persistence Journals.
Read from journal operation with events that were read.
API for reading persistent events and information derived
from stored persistent events.
API for reading persistent events and information derived
from stored persistent events.
A query plugin must implement a class that implements this trait.
Read persistent actor's sequence number operation.
Read persistent actor's sequence number operation.
Storage read operation for recovery of the persistent actor.
INTERNAL API
A specialized "receive" behavior that is implemented using message matching builders,
such as
ReceiveBuilder, from AbstractBehavior.Mutable builder used when implementing
AbstractBehavior.Used for building a partial function for
AbstractActor.createReceive().When using ActorContext.setReceiveTimeout, the singleton instance of ReceiveTimeout will be sent
to the Actor when there hasn't been any message for that long.
INTERNAL API
Register and discover actors that implement a service with a protocol defined by a
ServiceKey.The set of commands accepted by a Receptionist.
Remove association between the given
pekko.actor.typed.ActorRef and the given ServiceKey.Confirmation that the given
pekko.actor.typed.ActorRef no more associated with the ServiceKey in the local receptionist.Sent by the receptionist, available here for easier testing
Find message.Current listing of all Actors that implement the protocol given by the
ServiceKey.Sent by the receptionist, available here for easier testing
Register message.Confirmation that the given
pekko.actor.typed.ActorRef has been associated with the ServiceKey.Sent by the receptionist, available here for easier testing
Subscribe message.A Receptionist is an entry point into an Actor hierarchy where select Actors
publish their identity together with the protocols that they implement.
Marker interface to use with dynamic access
Internal API
Internal API
Can be used in
pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the Receptionist extension.FIXME doc
- not serializable
- not watchable
INTERNAL API
INTERNAL API
DNS Record Type
INTERNAL API
INTERNAL API
INTERNAL API
Recovery mode configuration object to be returned in
PersistenceRecovery.recovery().Strategy for recovery of snapshots and events.
Strategy for recovery of snapshots and events.
Strategy for recovery of snapshots and events.
Strategy for recovery of snapshots and events.
Sent to a
PersistentActor when the journal replay has been finished.INTERNAL API
Collection of internal reflection utilities which may or may not be
available (most services specific to HotSpot, but fails gracefully).
Collection of internal reflection utilities which may or may not be
available (most services specific to HotSpot, but fails gracefully).
This is the default
pekko.actor.DynamicAccess implementation used by pekko.actor.ExtendedActorSystem
unless overridden.Emulates rejection of operation by the journal with
error exception.Extractor for so-called “relative actor paths” as in “relative URI”, not in
“relative to some actor”.
Extractor for so-called “relative actor paths” as in “relative URI”, not in
“relative to some actor”.
ProducerController
ProducerController
DurableProducerQueue
DurableProducerQueue
DurableProducerQueue
DurableProducerQueue
DurableProducerQueue
DurableProducerQueue
ProducerController
ProducerController
ProducerController
ProducerController
ProducerController
ProducerController
ConsumerController
ConsumerController
DurableProducerQueue
DurableProducerQueue
INTERNAL API
INTERNAL API
Sent once for every started shard (but could be retried), should result in a response of either
UpdateDone or UpdateFailed
Sent once when the coordinator starts (but could be retried), should result in a response of
RememberedShards
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API.
INTERNAL API.
INTERNAL API
INTERNAL API
INTERNAL API
This is public with the purpose to document the used markers and properties of log events.
This is public with the purpose to document the used markers and properties of log events.
INTERNAL API
INTERNAL API
Extension that keeps track of remote metrics, such
as max size of different message types.
INTERNAL API
Extension that keeps track of remote metrics, such
as max size of different message types.
pekko.routing.RouterConfig implementation for remote deployment on defined
target nodes.RemoteTransportException represents a general failure within a RemoteTransport,
such as inability to start, wrong configuration etc.
RemoteTransportException without stack trace.INTERNAL API
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
ReplicatedData that has support for pruning of data
belonging to a specific node may implement this interface.INTERNAL API
Utility program that removes the internal data stored with Pekko Persistence
by the Cluster
ShardCoordinator.Remove a specific routee by sending this message to the router.
INTERNAL API
*
INTERNAL API
INTERNAL API
Identifies a replica in Replicated Event Sourcing, could be a datacenter name or a logical identifier.
Interface for implementing a state based convergent
replicated data type (CvRDT).
Protobuf type
org.apache.pekko.cluster.ddata.FlagProtobuf type
org.apache.pekko.cluster.ddata.FlagProtobuf type
org.apache.pekko.cluster.ddata.GCounterProtobuf type
org.apache.pekko.cluster.ddata.GCounterProtobuf type
org.apache.pekko.cluster.ddata.GCounter.EntryProtobuf type
org.apache.pekko.cluster.ddata.GCounter.EntryProtobuf type
org.apache.pekko.cluster.ddata.GSetProtobuf type
org.apache.pekko.cluster.ddata.GSetProtobuf type
org.apache.pekko.cluster.ddata.LWWMapProtobuf type
org.apache.pekko.cluster.ddata.LWWMapProtobuf type
org.apache.pekko.cluster.ddata.LWWMap.EntryProtobuf type
org.apache.pekko.cluster.ddata.LWWMap.EntryProtobuf type
org.apache.pekko.cluster.ddata.LWWRegisterProtobuf type
org.apache.pekko.cluster.ddata.LWWRegisterProtobuf type
org.apache.pekko.cluster.ddata.ORMapProtobuf type
org.apache.pekko.cluster.ddata.ORMapProtobuf type
org.apache.pekko.cluster.ddata.ORMap.EntryProtobuf type
org.apache.pekko.cluster.ddata.ORMap.EntryProtobuf type
org.apache.pekko.cluster.ddata.ORMapDeltaGroupProtobuf type
org.apache.pekko.cluster.ddata.ORMapDeltaGroupProtobuf type
org.apache.pekko.cluster.ddata.ORMapDeltaGroup.EntryProtobuf type
org.apache.pekko.cluster.ddata.ORMapDeltaGroup.EntryProtobuf type
org.apache.pekko.cluster.ddata.ORMapDeltaGroup.MapEntryProtobuf type
org.apache.pekko.cluster.ddata.ORMapDeltaGroup.MapEntryProtobuf enum
org.apache.pekko.cluster.ddata.ORMapDeltaOpProtobuf type
org.apache.pekko.cluster.ddata.ORMultiMapProtobuf type
org.apache.pekko.cluster.ddata.ORMultiMapProtobuf type
org.apache.pekko.cluster.ddata.ORMultiMap.EntryProtobuf type
org.apache.pekko.cluster.ddata.ORMultiMap.EntryProtobuf type
org.apache.pekko.cluster.ddata.ORSetProtobuf type
org.apache.pekko.cluster.ddata.ORSetProtobuf type
org.apache.pekko.cluster.ddata.ORSetDeltaGroupProtobuf type
org.apache.pekko.cluster.ddata.ORSetDeltaGroupProtobuf type
org.apache.pekko.cluster.ddata.ORSetDeltaGroup.EntryProtobuf type
org.apache.pekko.cluster.ddata.ORSetDeltaGroup.EntryProtobuf enum
org.apache.pekko.cluster.ddata.ORSetDeltaOpProtobuf type
org.apache.pekko.cluster.ddata.PNCounterProtobuf type
org.apache.pekko.cluster.ddata.PNCounterProtobuf type
org.apache.pekko.cluster.ddata.PNCounterMapProtobuf type
org.apache.pekko.cluster.ddata.PNCounterMapProtobuf type
org.apache.pekko.cluster.ddata.PNCounterMap.EntryProtobuf type
org.apache.pekko.cluster.ddata.PNCounterMap.EntryMarker trait for
ReplicatedData serialized by
pekko.cluster.ddata.protobuf.ReplicatedDataSerializer.Protobuf serializer of ReplicatedData.
ReplicatedDataSerializer.KeyComparator<A extends org.apache.pekko.protobufv3.internal.GeneratedMessage>
ReplicatedDataSerializer.ProtoMapEntryReader<Entry extends org.apache.pekko.protobufv3.internal.GeneratedMessage,A extends org.apache.pekko.protobufv3.internal.GeneratedMessage>
ReplicatedDataSerializer.ProtoMapEntryWriter<Entry extends org.apache.pekko.protobufv3.internal.GeneratedMessage,EntryBuilder extends org.apache.pekko.protobufv3.internal.GeneratedMessage.Builder<EntryBuilder>,Value extends org.apache.pekko.protobufv3.internal.GeneratedMessage>
The delta must implement this type.
Some complex deltas grow in size for each update and above a configured
threshold such deltas are discarded and sent as full state instead.
Settings for a specific replica id in replicated sharding
Currently only Entity's with ShardingEnvelope are supported but this may change in the future
Base class for replicated event sourced behaviors.
Protobuf type
CounterProtobuf type
CounterProtobuf type
CounterUpdateProtobuf type
CounterUpdateProtobuf type
ORSetProtobuf type
ORSetProtobuf type
ORSetDeltaGroupProtobuf type
ORSetDeltaGroupProtobuf type
ORSetDeltaGroup.EntryProtobuf type
ORSetDeltaGroup.EntryProtobuf enum
ORSetDeltaOpProtobuf type
PublishedEventProtobuf type
PublishedEventProtobuf type
ReplicatedEventMetadataProtobuf type
ReplicatedEventMetadataProtobuf type
ReplicatedPublishedEventMetaDataProtobuf type
ReplicatedPublishedEventMetaDataProtobuf type
ReplicatedSnapshotMetadataProtobuf type
ReplicatedSnapshotMetadataProtobuf type
ReplicatedSnapshotMetadata.SeenProtobuf type
ReplicatedSnapshotMetadata.SeenProtobuf type
VersionVectorProtobuf type
VersionVectorProtobuf type
VersionVector.EntryProtobuf type
VersionVector.EntryINTERNAL API
Represents the sharding instances for the replicas of one Replicated Event Sourcing entity type
Not for user extension.
Extension for running Replicated Event Sourcing in sharding by starting one separate instance of sharding per replica.
Provides access to replication specific state
Provides access to replication specific state
param: typeName The name of the entity type e.g.
INTERNAL API
A replicated in-memory data store supporting low latency and high availability
requirements.
The data value is retrieved with
Replicator.Changed.get(org.apache.pekko.cluster.ddata.Key<T>) using the typed key.The data value is retrieved with
Replicator.Changed.get(org.apache.pekko.cluster.ddata.Key<T>) using the typed key.The data value is retrieved with
pekko.cluster.ddata.Replicator.Changed.get using the typed key.Send this message to the local
Replicator to delete a data value for the
given key.Send this message to the local
Replicator to delete a data value for the
given key.Notify subscribers of changes now, otherwise they will be notified periodically
with the configured
notify-subscribers-interval.INTERNAL API
Obtain the instance of this class with the
Replicator.flushChanges() method.Notify subscribers of changes now, otherwise they will be notified periodically
with the configured
notify-subscribers-interval.Send this message to the local
Replicator to retrieve a data value for the
given key.Send this message to the local
Replicator to retrieve a data value for the
given key.The
Replicator.Get request couldn't be performed because the entry has been deleted.The
Replicator.Get request couldn't be performed because the entry has been deleted.The
Replicator.Get request could not be fulfill according to the given
consistency level and timeout.The
Replicator.Get request could not be fulfill according to the given
consistency level and timeout.INTERNAL API
Get current number of replicas, including the local replica.
Get current number of replicas, including the local replica.
Reply from
Get.Reply from
Get.INTERNAL API
If the
modify function of the Replicator.Update throws an exception the reply message
will be this ModifyFailure message.If the
modify function of the Replicator.Update throws an exception the reply message
will be this ModifyFailure message.ReadMajority but with the given number of additional nodes added to the majority count.Current number of replicas.
Current number of replicas.
Marker trait for remote messages serialized by
pekko.cluster.ddata.protobuf.ReplicatorMessageSerializer.The local store or direct replication of the
Replicator.Update could not be fulfill according to
the given consistency level due to durable store errors.The local store or direct replication of the
Replicator.Update could not be fulfill according to
the given consistency level due to durable store errors.Register a subscriber that will be notified with a
Replicator.Changed message
when the value of the given key is changed.Register a subscriber that will be notified with a
Replicator.Changed message
when the value of the given key is changed.Register a subscriber that will be notified with a
Changed message
when the value of the given key is changed.Unregister a subscriber.
Unregister a subscriber.
Unregister a subscriber.
The
Replicator.Update couldn't be performed because the entry has been deleted.The
Replicator.Update couldn't be performed because the entry has been deleted.The direct replication of the
Replicator.Update could not be fulfill according to
the given consistency level and
timeout.The direct replication of the
Replicator.Update could not be fulfill according to
the given consistency level and
timeout.WriteMajority but with the given number of additional nodes added to the majority count.INTERNAL API
INTERNAL API
When interacting with the
Replicator from an actor this class provides convenient
methods that adapts the response messages to the requesting actor's message protocol.When interacting with the
Replicator from an actor this class provides convenient
methods that adapts the response messages to the requesting actor's message protocol.Protobuf type
org.apache.pekko.cluster.ddata.AddressProtobuf type
org.apache.pekko.cluster.ddata.AddressProtobuf type
org.apache.pekko.cluster.ddata.ChangedProtobuf type
org.apache.pekko.cluster.ddata.ChangedProtobuf type
org.apache.pekko.cluster.ddata.DataEnvelopeProtobuf type
org.apache.pekko.cluster.ddata.DataEnvelopeProtobuf type
org.apache.pekko.cluster.ddata.DataEnvelope.PruningEntryProtobuf type
org.apache.pekko.cluster.ddata.DataEnvelope.PruningEntryProtobuf type
org.apache.pekko.cluster.ddata.DeltaPropagationProtobuf type
org.apache.pekko.cluster.ddata.DeltaPropagationProtobuf type
org.apache.pekko.cluster.ddata.DeltaPropagation.EntryProtobuf type
org.apache.pekko.cluster.ddata.DeltaPropagation.EntryProtobuf type
org.apache.pekko.cluster.ddata.DurableDataEnvelopeProtobuf type
org.apache.pekko.cluster.ddata.DurableDataEnvelopeProtobuf type
org.apache.pekko.cluster.ddata.EmptyProtobuf type
org.apache.pekko.cluster.ddata.EmptyProtobuf type
org.apache.pekko.cluster.ddata.GetProtobuf type
org.apache.pekko.cluster.ddata.GetProtobuf type
org.apache.pekko.cluster.ddata.GetFailureProtobuf type
org.apache.pekko.cluster.ddata.GetFailureProtobuf type
org.apache.pekko.cluster.ddata.GetSuccessProtobuf type
org.apache.pekko.cluster.ddata.GetSuccessProtobuf type
org.apache.pekko.cluster.ddata.GossipProtobuf type
org.apache.pekko.cluster.ddata.GossipProtobuf type
org.apache.pekko.cluster.ddata.Gossip.EntryProtobuf type
org.apache.pekko.cluster.ddata.Gossip.EntryProtobuf type
org.apache.pekko.cluster.ddata.NotFoundProtobuf type
org.apache.pekko.cluster.ddata.NotFoundProtobuf type
org.apache.pekko.cluster.ddata.OtherMessageProtobuf type
org.apache.pekko.cluster.ddata.OtherMessageProtobuf type
org.apache.pekko.cluster.ddata.ReadProtobuf type
org.apache.pekko.cluster.ddata.ReadProtobuf type
org.apache.pekko.cluster.ddata.ReadResultProtobuf type
org.apache.pekko.cluster.ddata.ReadResultProtobuf type
org.apache.pekko.cluster.ddata.StatusProtobuf type
org.apache.pekko.cluster.ddata.StatusProtobuf type
org.apache.pekko.cluster.ddata.Status.EntryProtobuf type
org.apache.pekko.cluster.ddata.Status.EntryProtobuf type
org.apache.pekko.cluster.ddata.StringGSetProtobuf type
org.apache.pekko.cluster.ddata.StringGSetProtobuf type
org.apache.pekko.cluster.ddata.SubscribeProtobuf type
org.apache.pekko.cluster.ddata.SubscribeProtobuf type
org.apache.pekko.cluster.ddata.UniqueAddressProtobuf type
org.apache.pekko.cluster.ddata.UniqueAddressProtobuf type
org.apache.pekko.cluster.ddata.UnsubscribeProtobuf type
org.apache.pekko.cluster.ddata.UnsubscribeProtobuf type
org.apache.pekko.cluster.ddata.VersionVectorProtobuf type
org.apache.pekko.cluster.ddata.VersionVectorProtobuf type
org.apache.pekko.cluster.ddata.VersionVector.EntryProtobuf type
org.apache.pekko.cluster.ddata.VersionVector.EntryProtobuf type
org.apache.pekko.cluster.ddata.WriteProtobuf type
org.apache.pekko.cluster.ddata.WriteProtobuf serializer of ReplicatorMessage messages.
A cache that is designed for a small number (<= 32) of
entries.
INTERNAL API
param: roles Replicas are running on members tagged with these roles.
INTERNAL API: Marker trait for reply messages
EventSourcedBehaviorWithEnforcedReplies can be used to enforce that replies are not forgotten.EventSourcedBehavior.withEnforcedReplies can be used to enforce that replies are not forgotten.DurableStateBehaviorWithEnforcedReplies can be used to enforce that replies are not forgotten.DurableStateBehavior.withEnforcedReplies can be used to enforce that replies are not forgotten.Reply to sender with predefined response, and discard the received message silently.
RepointableActorRef (and potentially others) may change their locality at
runtime, meaning that isLocal might not be stable.
INTERNAL API
INTERNAL API
Marker that specifies that the deltas must be applied in causal order.
Trait to signal that an Actor requires a certain type of message queue semantics.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
Pool routers with dynamically resizable number of routees are implemented by providing a Resizer
implementation in the pekko.routing.Pool configuration.Not for user extension
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
A RestartFlow wraps a
Flow that gets restarted when it completes or fails.A RestartFlow wraps a
Flow that gets restarted when it completes or fails.A RestartFlow wraps a
Flow that gets restarted when it completes or fails.A RestartFlow wraps a
Flow that gets restarted when it completes or fails.A RestartSink wraps a
Sink that gets restarted when it completes or fails.A RestartSink wraps a
Sink that gets restarted when it completes or fails.A RestartSink wraps a
Sink that gets restarted when it completes or fails.A RestartSink wraps a
Sink that gets restarted when it completes or fails.A RestartSource wraps a
Source that gets restarted when it completes or fails.A RestartSource wraps a
Source that gets restarted when it completes or fails.A RestartSource wraps a
Source that gets restarted when it completes or fails.A RestartSource wraps a
Source that gets restarted when it completes or fails.Not for user extension
Temporary attribute that can override the time a
RestartWithBackoffFlow waits
for a failure before cancelling.Shared logic for all restart with backoff logics.
Criteria for retention/deletion of snapshots and events.
Criteria for retention/deletion of snapshots and events.
Criteria for retention/deletion of snapshots and events.
Criteria for retention/deletion of snapshots and events.
This trait provides the retry utility function
INTERNAL API
INTERNAL API
INTERNAL API.
Root of the hierarchy of ActorPaths.
Variation on ConfigSSLEngineProvider that will periodically reload the keys and certificates
from disk, to facilitate rolling updates of certificates.
A router group that uses round-robin to select a routee.
A router pool that uses round-robin to select a routee.
Uses round-robin to select a routee.
INTERNAL API
Abstraction of a destination for messages routed via a
Router.Message used to carry information about what routees the router is currently using.
For each message that is sent through the router via the
Router.route(java.lang.Object, org.apache.pekko.actor.ActorRef) method the
RoutingLogic decides to which Routee to send the message.This trait represents a router factory: it produces the actual router actor
and creates the routing table (a function which determines the recipients
for each message which is to be dispatched).
Only the contained message will be forwarded to the
destination, i.e.
INTERNAL API
Kept in the behavior, not shared between instances, meant to be stateful.
The interface of the routing logic that is used in a
Router to select
destination routed messages.INTERNAL API
INTERNAL API
Java API
INTERNAL API
INTERNAL API
A stream interpreter that is running/has been started
The RejectedExecutionHandler used by Akka, it improves on CallerRunsPolicy
by throwing a RejectedExecutionException if the executor isShutdown.
Sent to a
PersistentActor after failed saving of a snapshot.Sent to a
PersistentActor after successful saving of a snapshot.Contains the Scala API (!-method) for ActorSelections) which provides automatic tracking of the sender,
as per the usual implicit ActorRef pattern.
INTERNAL API
INTERNAL API
Allows access to an SSLSession with Scala types
A ScalaTest base class for the
ActorTestKit, making it possible to have ScalaTest manage the lifecycle of the testkit.A ScalaTest base trait for the
ActorTestKit which ScalaTestWithActorTestKit extends.Maps Classifiers to Subscribers and selects which Subscriber should receive which publication through scanning through all Subscribers
through the matches(classifier, event) method
Java API: See documentation for
pekko.event.ScanningClassification
E is the Event type
S is the Subscriber type
C is the Classifier typeA router group that broadcasts the message to all routees, and replies with the first response.
A router pool that broadcasts the message to all routees, and replies with the first response.
Broadcasts the message to all routees, and replies with the first response.
An Apache Pekko scheduler service.
The ActorSystem facility for scheduling tasks.
INTERNAL API
If a
TaskRunOnClose is used in scheduleOnce it will be run when the Scheduler is
closed (ActorSystem shutdown).INTERNAL API
This exception is thrown by Scheduler.schedule* when scheduling is not
possible, e.g.
A Task that will be notified when it is cancelled.
Deprecated.
Classic remoting is deprecated, use Artery.
The scope of a
pekko.actor.Deploy serves two purposes: as a marker for
pattern matching the “scope” (i.e.INTERNAL API
INTERNAL API
INTERNAL API
From AESCounterRNG API docs:
Valid values are 16 (128 bits), 24 (192 bits) and 32 (256 bits).
INTERNAL API
From AESCounterRNG API docs:
Valid values are 16 (128 bits), 24 (192 bits) and 32 (256 bits).
INTERNAL API
Plugin API: a selected snapshot matching
SnapshotSelectionCriteria.INTERNAL API
INTERNAL API
INTERNAL API
Subscribe to this node being removed from the cluster.
Cluster non-specific (typed vs classic) wrapper for
pekko.cluster.UniqueAddress.Subscribe to this node being up, after sending this event the subscription is automatically
cancelled.
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Corresponds to an ordered sequence number for the events.
Serialization module.
Serialization information needed for serializing local actor refs,
or if serializer library e.g.
SerializationExtension is a Pekko Extension to interact with the Serialization
that is built into Akka
SerializationExtension is a Pekko Extension to interact with the Serialization
that is built into Akka
Setup for the serialization subsystem, constructor is *Internal API*, use factories in
SerializationSetupSome useful serialization helper methods.
Utilities to test serialization.
Utilities to test serialization.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
A Serializer represents a bimap between an object and an array of bytes representing that object.
Constructor is internal API: Use the factories
SerializerDetails.create(java.lang.String, org.apache.pekko.serialization.Serializer, java.util.List<java.lang.Class<?>>) or SerializerDetails.apply(java.lang.String, org.apache.pekko.serialization.Serializer, scala.collection.immutable.Seq<java.lang.Class<?>>)
to constructA Serializer represents a bimap between an object and an array of bytes representing that object.
INTERNAL API.
The server is usually the side the provides the service to its interlocutor.
INTERNAL API.
INTERNAL API.
Implement to provide a service discovery method
Future returned by resolve(name, timeout) should be failed with this exception
if the underlying mechanism was unable to resolve the name within the given timeout.
Result of a successful resolve request
Resolved target host, with optional port and the IP address.
A service key is an object that implements this trait for a given protocol
T, meaning that it signifies that the type T is the entry point into the
protocol spoken by that service (think of it as the set of first messages
that a client could send).
Internal API
INTERNAL API
Allows hooking in extra verification before finishing the SSL handshake.
The configuration settings that were parsed from the config by an
ActorSystem.Marker supertype for a setup part that can be put inside
pekko.actor.setup.ActorSystemSetup, if a specific concrete setup
is not specified in the actor system setup that means defaults are used (usually from the config file) - no concrete
setup instance should be mandatory in the pekko.actor.setup.ActorSystemSetup that an actor system is created with.Routee that sends each message to all routees.A Shape describes the inlets and outlets of a
Graph.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Singleton coordinator that decides where to allocate shards.
Java API: Java implementations of custom shard allocation and rebalancing logic used by the
ShardCoordinator
should extend this abstract class and implement the two methods.Shard allocation strategy where start is called by the shard coordinator before any calls to
rebalance or allocate shard.
INTERNAL API
Messages sent to the coordinator
Messages sent from the coordinator
Use
pekko.cluster.sharding.ShardCoordinator.ShardAllocationStrategy.leastShardAllocationStrategy instead.Interface of the pluggable shard allocation and rebalancing logic used by the
ShardCoordinator.Shard allocation strategy where start is called by the shard coordinator before any calls to
rebalance or allocate shard.
This extension runs a pre set number of actors in a cluster.
This extension runs a pre set number of actors in a cluster.
INTERNAL API
Not for user constructions, use factory methods to instantiate.
INTERNAL API
ShardingConsumerController is used together with ShardingProducerController.ShardingConsumerController is used together with ShardingProducerController.INTERNAL API
INTERNAL API
Not for user extension
INTERNAL API
Default envelope type that may be used with Cluster Sharding.
INTERNAL API
INTERNAL API
This is public with the purpose to document the used markers and properties of log events.
INTERNAL API
This is public with the purpose to document the used markers and properties of log events.
Entirely customizable typed message extractor.
Protobuf type
org.apache.pekko.cluster.sharding.typed.ShardingEnvelopeProtobuf type
org.apache.pekko.cluster.sharding.typed.ShardingEnvelopeReliable delivery between a producer actor sending messages to sharded consumer
actors receiving the messages.
For sending confirmation message back to the producer when the message has been confirmed.
The
ProducerController sends RequestNext to the producer when it is allowed to send one
message via the sendNextTo or askNextTo.Initial message from the producer actor.
Reliable delivery between a producer actor sending messages to sharded consumer
actors receiving the messages.
For commands defined in public ShardingProducerController
INTERNAL API
INTERNAL API
INTERNAL API
The result of a group query and metadata.
INTERNAL API
INTERNAL API
INTERNAL API
A
SharedKillSwitch is a provider for Graphs of FlowShape that can be completed or failed from the outside.For testing only.
Deprecated.
Use another journal implementation or the in-mem journal in combination with the journal-proxy.
INTERNAL API
INTERNAL API
Loads metrics through Hyperic SIGAR and JMX monitoring beans.
Provide sigar instance as
SigarProxy.System signals are notifications that are generated by the system and
delivered to the Actor behavior in a reliable fashion (i.e.
Mutable builder for handling signals in
EventSourcedBehaviorMutable builder for handling signals in
DurableStateBehaviorFor cases where O == I for BehaviorInterceptor.
SingleConsumerOnlyUnboundedMailbox is a high-performance, multiple producer—single consumer, unbounded MailboxType,
with the drawback that you can't have multiple consumers,
which rules out using it with BalancingPool (BalancingDispatcher) for instance.
Java API
A
Sink is a set of stream processing steps that has one open input.Java API
This trait allows to have a queue as a sink for a stream.
This trait allows to have a queue as a sink for a stream.
This trait adds cancel support to
SinkQueue.This trait adds cancel support to
SinkQueue.A
SinkRef allows sharing a "reference" to a scaladsl.Sink with others, with the main purpose of crossing a network boundary.See full documentation on
SinkRef.INTERNAL API
INTERNAL API
A Sink
Shape has exactly one input and no outputs, it models a data sink.SLF4J logger.
Base trait for all classes that wants to be able use the SLF4J logging infrastructure.
pekko.event.LoggingFilter that uses the log level defined in the SLF4J
backend configuration (e.g.Wraps
MarkerFactory for creating
LogMarker that wraps MarkerA router pool that tries to send to the non-suspended routee with fewest messages in mailbox.
Tries to send to the non-suspended routee with fewest messages in mailbox.
Wrapper for snapshot
data.Facility to convert snapshots from and to a specialized data model.
SnapshotAfter Extension Id and factory for creating SnapshotAfter extension
INTERNAL API
Snapshot metainformation.
Snapshot metadata.
Snapshot metadata.
Offers a
PersistentActor a previously saved snapshot during recovery.INTERNAL API
Operations supported by snapshot plugin
INTERNAL API.
Instructs snapshot store to delete a snapshot.
Instructs snapshot store to delete all snapshots that match
criteria.Instructs a snapshot store to load a snapshot.
Reply message to a failed
SnapshotProtocol.LoadSnapshot request.Response message to a
SnapshotProtocol.LoadSnapshot message.Marker trait shared by internal snapshot messages.
Internal snapshot command.
Internal snapshot acknowledgement.
Instructs snapshot store to save a snapshot.
INTERNAL API.
Selection criteria for loading and deleting snapshots.
Selection criteria for loading and deleting snapshots.
Snapshot serializer.INTERNAL API
INTERNAL API
INTERNAL API
Java API: abstract snapshot store.
Abstract snapshot store.
This spec aims to verify custom pekko-persistence
SnapshotStore implementations.Snapshot API on top of the internal snapshot protocol.
Class for testing persisted snapshots in persistent actors.
Class for testing snapshots of persistent actors.
Utilities to get free socket address.
Utilities to get free socket address.
Java API
A
Source is a set of stream processing steps that has one open output.Java API
This trait allows to have a queue as a data source for some stream.
This trait allows to have a queue as a data source for some stream.
This trait adds completion support to
SourceQueue.This trait adds completion support to
SourceQueue.A SourceRef allows sharing a "reference" with others, with the main purpose of crossing a network boundary.
See full documentation on
SourceRef.INTERNAL API
INTERNAL API
A Source
Shape has exactly one output and no inputs, it models a source
of data.A source that provides operations which automatically propagate the context of an element.
A source that provides operations which automatically propagate the context of an element.
A message protocol for actors that support spawning a child actor when receiving a
SpawnProtocol#Spawn
message and sending back the ActorRef of the child actor.Not for user extension
Spawn a child actor with the given
behavior and send back the ActorRef of that child to the given
replyTo destination.A message protocol for actors that support spawning a child actor when receiving a
SpawnProtocol#Spawn
message and sending back the ActorRef of the child actor.INTERNAL API
See reference documentation: https://pekko.apache.org/docs/pekko/current/split-brain-resolver.html
INTERNAL API
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Setup for defining a
SSLEngineProvider that is passed in when ActorSystem
is created rather than creating one from configured class name.StablePriorityBlockingQueue is a blocking priority queue that preserves order for elements of equal priority.
StablePriorityQueue is a priority queue that preserves order for elements of equal priority.
Simple way to obtain a
pekko.event.LoggingAdapter when used together with an pekko.stream.Materializer.Definitions of the built-in standard metrics.
Definitions of the built-in standard metrics.
Allows starting a specific Sharded Entity by its entity identifier
Allows starting a specific Sharded Entity by its entity identifier
Allows starting a specific Sharded Entity by its entity identifier
Allows starting a specific Sharded Entity by its entity identifier
The
Stash trait enables an actor to temporarily stash away messages that can not or
should not be handled using the actor's current behavior.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
A non thread safe mutable message buffer that can be used to buffer messages inside actors
and then unstash them.
A non thread safe mutable message buffer that can be used to buffer messages inside actors
and then unstash them.
INTERNAL API
INTERNAL API
INTERNAL API.
INTERNAL API: Stash management for persistent behaviors
INTERNAL API: Stash management for persistent behaviors
Is thrown when the size of the Stash exceeds the capacity of the Stash
Is thrown when the size of the stash exceeds the capacity of the stash buffer.
Is thrown when the size of the stash exceeds the capacity of the stash buffer.
This defines how to handle the current received message which failed to stash, when the size of
Stash exceeding the capacity of Stash.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Implement this interface in order to configure the stashOverflowStrategy for
the internal stash of persistent actor.
INTERNAL API
INTERNAL API
A special accumulator for
StatefulMapConcat operator that allows to emit elements when the upstream has completed.A special accumulator for
StatefulMapConcat operator that allows to emit elements when the upstream has completed.A factory for creating
StatefulMapConcatAccumulator instances.A factory for creating
StatefulMapConcatAccumulator instances.Superseeded by
pekko.pattern.StatusReply, prefer that when possible.This class/message type is preferably used to indicate failure of some operation performed.
This class/message type is preferably used to indicate success of some operation performed.
Superseeded by
pekko.pattern.StatusReply, prefer that when possible.Generic top-level message type for replies that signal failure or success.
Scala API for creating and pattern matching an error response
Carrier exception used for textual error descriptions.
Scala API for creation and pattern matching a successful response.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Emulates exception thrown by the storage on the attempt to perform some operation.
Converters for interacting with the blocking
java.io streams APIs and Java 8 StreamsConverters for interacting with the blocking
java.io streams APIs and Java 8 StreamsConverters for interacting with the blocking
java.io streams APIs and Java 8 StreamsConverters for interacting with the blocking
java.io streams APIs and Java 8 StreamsThis exception signals that materialized value is already detached from stream.
Attributes for stream refs (
pekko.stream.SourceRef and pekko.stream.SinkRef).Attributes specific to stream refs.
Attributes for stream refs (
pekko.stream.SourceRef and pekko.stream.SinkRef).Protobuf type
ActorRefProtobuf type
ActorRefProtobuf type
CumulativeDemandProtobuf type
CumulativeDemandProtobuf type
OnSubscribeHandshakeProtobuf type
OnSubscribeHandshakeProtobuf type
PayloadProtobuf type
PayloadProtobuf type
RemoteStreamCompletedProtobuf type
RemoteStreamCompletedProtobuf type
RemoteStreamFailureProtobuf type
RemoteStreamFailureProtobuf type
SequencedOnNextProtobuf type
SequencedOnNextProtobuf type
SinkRefProtobuf type
SinkRefProtobuf type
SourceRefProtobuf type
SourceRefINTERNAL API: Adds support for serializing and deserializing
pekko.stream.SourceRef and pekko.stream.SinkRef.The stream ref resolver provides a way to serialize and deserialize streamrefs in user serializers.
The stream ref resolver extension provides a way to serialize and deserialize streamrefs in user serializers.
Factories for creating stream refs.
Factories for creating stream refs.
Factories for creating stream refs.
Factories for creating stream refs.
A snapshot of one running stream
Leaked publishers and subscribers are cleaned up when they are not used within a given
deadline, configured by
StreamSubscriptionTimeoutSettings.This mode describes what shall happen when the subscription timeout expires for
substream Publishers created by operations like
prefixAndTail.INTERNAL API
INTERNAL API
Base class for timeout exceptions specific to Pekko Streams
Classification which respects relationships between channels: subscribing
to one channel automatically and idempotently subscribes to all sub-channels.
Java API: See documentation for
pekko.event.SubchannelClassification
E is the Event type
S is the Subscriber type
C is the Classifier typeTypeclass which describes a classification hierarchy.
A “stream of streams” sub-flow of data elements, e.g.
A “stream of streams” sub-flow of data elements, e.g.
Subscribe to cluster state changes.
Subscribe to a cluster receptionist's client interactions where
it is guaranteed that a sender receives the initial state
of contact points prior to any events in relation to them
changing.
Subscribe to a cluster client's contact point changes where
it is guaranteed that a sender receives the initial state
of contact points prior to any events in relation to them
changing.
Extension of Subscription that allows to pass a cause when a subscription is cancelled.
Not for user extension
A “stream of streams” sub-flow of data elements, e.g.
* Upcast a stream of elements to a stream of supertypes of that element.
INTERNAL API
INTERNAL API
Deprecated.
Use .withAttributes(ActorAttributes.supervisionStrategy(equivalentDecider)) rather than a SubstreamCancelStrategy.
Deprecated.
Use .withAttributes(ActorAttributes.supervisionStrategy(equivalentDecider)) rather than a SubstreamCancelStrategy.
INTERNAL API
A behavior type that could be supervised, Not for user extension.
Scala API: The element is dropped and the stream continues after restarting the operator
if application code for processing an element throws an exception.
Scala API: The element is dropped and the stream continues if application code for processing
an element throws an exception.
Scala API: The stream will be completed with failure if application code for processing an element
throws an exception.
INTERNAL API
INTERNAL API
A Pekko SupervisorStrategy is the policy to apply for crashing children.
Not for user extension
Escalates the failure to the supervisor of the supervisor,
by rethrowing the cause of the failure, i.e.
Discards the old Actor instance and replaces it with a new,
then resumes message processing.
INTERNAL API
Resumes message processing for the failed Actor
Stops the Actor
Implement this interface in order to configure the supervisorStrategy for
the top-level guardian actor (
/user).Similar to
DeadLetter with the slight twist of NOT being logged by the default dead letters listener.An atomic switch that can be either on or off
INTERNAL API
For the purpose of orderly shutdown it's possible
to register interest in the termination of systemGuardian
and receive a notification
TerminationHook
before systemGuardian is stopped.INTERNAL API
MetricsSelector that uses the system load average metrics.
MetricsSelector that uses the system load average metrics.
The system materializer is a default materializer to use for most cases running streams, it is a single instance
per actor system that is tied to the lifecycle of that system.
System messages are handled specially: they form their own queue within
each actor’s mailbox.
System messages are handled specially: they form their own queue within
each actor’s mailbox.
INTERNAL API
INTERNAL API
Protobuf type
DeathWatchNotificationDataProtobuf type
DeathWatchNotificationDataProtobuf type
FailedDataProtobuf type
FailedDataProtobuf type
SuperviseDataProtobuf type
SuperviseDataProtobuf type
SystemMessageProtobuf type
SystemMessageProtobuf enum
SystemMessage.TypeProtobuf type
WatchDataProtobuf type
WatchDataINTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
The journal may support tagging of events that are used by the
EventsByTag query and it may support specifying the tags via an
pekko.persistence.journal.EventAdapter that wraps the events
in a Tagged with the given tags.A router group with retry logic, intended for cases where a return message is expected in
response to a message sent to the routee.
A router pool with retry logic, intended for cases where a return message is expected in
response to a message sent to the routee.
As each message is sent to the router, the routees are randomly ordered.
INTERNAL API
TCP Extension for Akka’s IO layer.
An abort operation will not flush pending writes and will issue a TCP ABORT
command to the O/S kernel which should result in a TCP_RST packet being sent
to the peer.
The connection has been aborted in response to an
Abort command.The Bind message is send to the TCP manager actor, which is obtained via
TcpExt.manager() in order to bind to a listening socket.The sender of a
Tcp.Bind command will—in case of success—receive confirmation
in this form.A normal close operation will first flush pending writes and then close the
socket.
Common interface for all commands which aim to close down an open connection.
The connection has been closed normally in response to a
Close command.This is the common trait for all commands understood by TCP actors.
Whenever a command cannot be completed, the queried actor will reply with
this message, wrapping the original command which failed.
A write command which aggregates two other write commands.
A confirmed close operation will flush pending writes and half-close the
connection, waiting for the peer to close the other half.
The connection has been half-closed by us and then half-close by the peer
in response to a
ConfirmedClose command.The Connect message is sent to the TCP manager actor, which is obtained via
TcpExt.manager().The connection actor sends this message either to the sender of a
Tcp.Connect
command (for outbound) or to the handler for incoming connections designated
in the Tcp.Bind message.This is the common interface for all events which indicate that a connection
has been closed or half-closed.
The connection has been closed due to an IO error.
Common interface for all events generated by the TCP layer actors.
Represents an accepted incoming TCP connection.
Represents an accepted incoming TCP connection.
The common interface for
Tcp.Command and Tcp.Event.Each
Tcp.WriteCommand can optionally request a positive acknowledgment to be sent
to the commanding actor.Default
Tcp.NoAck instance which is used when no acknowledgment information is
explicitly provided.Represents a prospective outgoing TCP connection.
Represents a prospective outgoing TCP connection.
The peer has closed its writing half of the connection.
Whenever data are read from a socket they will be transferred within this
class to the handler actor which was designated in the
Tcp.Register message.This message must be sent to a TCP connection actor after receiving the
Tcp.Connected message.This message enables the accepting of the next connection if read throttling is enabled
for connection actors.
This command needs to be sent to the connection actor after a
SuspendReading
command in order to resume reading from the socket.When
useResumeWriting is in effect as was indicated in the Tcp.Register message
then this command needs to be sent to the connection actor in order to re-enable
writing after a Tcp.CommandFailed event.Represents a prospective TCP server binding.
Represents a successful TCP server binding.
Common supertype of
Tcp.Write and WriteFile.Scala API: this object contains all applicable socket options for TCP.
Sending this command to the connection actor will disable reading from the TCP
socket.
In order to close down a listening socket, send this message to that socket’s
actor (that is the actor which previously had sent the
Tcp.Bound message).The sender of an
Unbind command will receive confirmation through this
message once the listening socket has been closed.Write data to the TCP connection.
Common interface for all write commands.
Write
count bytes starting at position from file at filePath to the connection.When
useResumeWriting is in effect as indicated in the Tcp.Register message,
the ResumeWriting command will be acknowledged by this message type, upon
which it is safe to send at least one write.TCP Extension for Akka’s IO layer.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Java API for accessing socket options.
Java API for accessing socket options.
When Death Watch is used, the watcher will receive a Terminated(watched)
message when watched is terminated.
Lifecycle signal that is fired when an Actor that was watched has terminated.
This special ActorRef is exclusively for use during unit testing in a single-threaded environment.
A collection of common actor patterns used in tests.
BlackholeActor does nothing for incoming messages, its like a blackhole.
EchoActor sends back received messages (unmodified).
ForwardActor forwards all messages as-is to specified ActorRef.
A collection of common actor patterns used in tests.
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
A cyclic barrier wrapper for use in testing.
Access to the
pekko.remote.testconductor.TestConductorExt extension:Access to the
pekko.remote.testconductor.TestConductorExt extension:This binds together the
pekko.remote.testconductor.Conductor and
pekko.remote.testconductor.Player roles inside a Pekko
pekko.actor.Extension.Protobuf type
AddressProtobuf type
AddressProtobuf type
AddressRequestProtobuf type
AddressRequestProtobuf enum
BarrierOpProtobuf enum
DirectionProtobuf type
EnterBarrierProtobuf type
EnterBarrierProtobuf enum
FailTypeProtobuf type
HelloProtobuf type
HelloProtobuf type
InjectFailureProtobuf type
InjectFailureProtobuf type
WrapperProtobuf type
WrapperFor testing purposes this
EntityRef can be used in place of a real pekko.cluster.sharding.typed.javadsl.EntityRef.For testing purposes this
EntityRef can be used in place of a real pekko.cluster.sharding.typed.scaladsl.EntityRef.For testing purposes this
EntityRef can be used in place of a real pekko.cluster.sharding.typed.javadsl.EntityRef.For testing purposes this
EntityRef can be used in place of a real pekko.cluster.sharding.typed.scaladsl.EntityRef.Implementation helpers of the EventFilter facilities: send
Mute
to the TestEventListener to install a filter, and UnMute to
uninstall it.Implementation helpers of the EventFilter facilities: send
Mute
to the TestEventFilter to install a filter, and UnMute to
uninstall it.EventListener for running tests, which allows selectively filtering out
expected messages.
A predefined exception that can be used in tests.
A predefined exception that can be used in tests.
This is a specialized form of the TestActorRef with support for querying and
setting the state of a FSM.
Utility for use as an
ActorRef when *synchronously* testing pekko.actor.typed.Behavior
with pekko.actor.testkit.typed.javadsl.BehaviorTestKit.Utility for use as an
ActorRef when *synchronously* testing pekko.actor.typed.Behavior
with pekko.actor.testkit.typed.javadsl.BehaviorTestKit.This Serializer uses standard Java Serialization and is useful for tests where ad-hoc messages are created and sent
between actor systems.
Java API: Test kit for testing actors.
Test kit for testing actors.
Implementation trait behind the
pekko.testkit.TestKit class: you may use
this if inheriting from a concrete class is not possible.A Junit external resource for the
ActorTestKit, making it possible to have Junit manage the lifecycle of the testkit.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
A count down latch wrapper for use in testing.
INTERNAL API
Java API: * Create instances through the
create factories in the TestProbe companion
or via ActorTestKit.createTestProbe().Create instances through the factories in the
TestProbe companion.TestKit-based probe which allows sending, reception and reply.
Provides factory methods for various Publishers.
Single subscription and demand tracking for
TestPublisher.ManualProbe.Provides factory methods for various Publishers.
Java API
Factory methods for test sinks.
Java API
Factory methods for test sinks.
Java API
Factory methods for test sources.
Java API
Factory methods for test sources.
Implementation of
Subscriber that allows various assertions.Single subscription tracking for
TestSubscriber.ManualProbe.Deprecated.
Classic remoting is deprecated, use Artery.
Base trait for activities that are logged by
pekko.remote.transport.TestTransport.Shared state among
pekko.remote.transport.TestTransport instances.Test utility to make behavior of functions that return some Future[B] controllable from tests.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
A DSL to configure and create a MessageDispatcher with a ThreadPoolExecutor
INTERNAL API
INTERNAL API
Represents a mode that decides how to deal exceed rate for Throttle operator
Makes throttle fail with exception when upstream is faster than throttle rate
Tells throttle to make pauses before emitting messages to meet throttle rate
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Management Command to force disassociation of an address.
Management Command to force disassociation of an address with an explicit error.
Use as replacement for an original exception when it can't be serialized or deserialized.
Helper class for determining whether a
Throwable is fatal or not.Helper class for determining whether a
Throwable is fatal or not.Throw
pekko.actor.StashOverflowException, hence the persistent actor will starting recovery
if guarded by default supervisor strategy.Throw
pekko.actor.StashOverflowException, hence the persistent actor will starting recovery
if guarded by default supervisor strategy.Corresponds to an ordered unique identifier of the events.
A Timeout is a wrapper on top of Duration to be more specific about what the duration means.
Provides timer related facilities to a
GraphStageLogic.Java API:
TimerGraphStageLogic with StageLogging.Scala API: Mix in Timers into your Actor to get support for scheduled
self messages via TimerScheduler.Support for scheduled
self messages in an actor.Support for scheduled
self messages in an actor.Support for scheduled
self messages in an actor.INTERNAL API
INTERNAL API
Stream cipher support based upon JSSE.
Stream cipher support based upon JSSE.
Stream cipher support based upon JSSE.
Stream cipher support based upon JSSE.
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.All streams in Pekko are unidirectional: while in a complex flow graph data
may flow in multiple directions these individual flows are independent from
each other.
This object holds simple wrapping
pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired.This object holds simple wrapping
pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired.This object holds simple wrapping
pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired.This object holds simple wrapping
pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired.Initiate a new session negotiation.
Send the given
pekko.util.ByteString across the encrypted session to the
peer.Plaintext bytes emitted by the SSLEngine are received over one specific
encryption session and this class bundles the bytes with the SSLSession
object.
If the underlying transport is closed before the final TLS closure command
is received from the peer then the SSLEngine will throw an SSLException that
warns about possible truncation attacks.
This is the supertype of all messages that the SslTls operator emits on the
plaintext side.
This is the supertype of all messages that the SslTls operator accepts on its
plaintext side.
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.
This exception signals that the maximum number of substreams declared has been exceeded.
INTERNAL API
A pub sub topic is an actor that handles subscribing to a topic and publishing messages to all subscribed actors.
Not for user extension
Scala API: Get a summary of the state for a local topic actor.
Scala API: Publish the message to all currently known subscribers.
Scala API: Subscribe to this topic.
Response to the
GetTopicStats query.Scala API: Unsubscribe a previously subscribed actor from this topic.
A pub sub topic is an actor that handles subscribing to a topic and publishing messages to all subscribed actors.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Deprecated.
Classic remoting is deprecated, use Artery.
Class to convert ordinary
pekko.actor.ActorRef instances to an AssociationEventListener.An interface that needs to be implemented by the user of a transport to listen to association events
Message sent to a
pekko.remote.transport.Transport.AssociationEventListener registered to a transport
(via the Promise returned by pekko.remote.transport.Transport#listen) when an inbound association request arrives.Indicates that the association setup request is invalid, and it is impossible to recover (malformed IP address,
hostname, etc.).
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
Deprecated.
Classic remoting is deprecated, use Artery.
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Used to create tuples with 10 elements in Java.
Used to create tuples with 11 elements in Java.
Used to create tuples with 12 elements in Java.
Used to create tuples with 13 elements in Java.
Used to create tuples with 14 elements in Java.
Used to create tuples with 15 elements in Java.
Used to create tuples with 16 elements in Java.
Used to create tuples with 17 elements in Java.
Used to create tuples with 18 elements in Java.
Used to create tuples with 19 elements in Java.
Used to create tuples with 20 elements in Java.
Used to create tuples with 21 elements in Java.
Used to create tuples with 22 elements in Java.
Used to create tuples with 3 elements in Java.
Used to create tuples with 4 elements in Java.
Used to create tuples with 5 elements in Java.
Used to create tuples with 6 elements in Java.
Used to create tuples with 7 elements in Java.
Used to create tuples with 8 elements in Java.
Used to create tuples with 9 elements in Java.
This trait is not meant to be extended by user code.
INTERNAL API
INTERNAL API: Adds support for serializing and deserializing
pekko.actor.typed.ActorRef.INTERNAL API
An immutable multi-map that expresses the value type as a type function of the key
type.
UDP Extension for Akka’s IO layer.
Send this message to the
UdpExt.manager() in order to bind to the given
local port (or an automatically assigned one if the port number is zero).This message is sent by the listener actor in response to a
Udp.Bind command.The common type of all commands supported by the UDP implementation.
When a command fails it will be replied to with this message type,
wrapping the failing command object.
The common type of all events emitted by the UDP implementation.
The common interface for
Udp.Command and Udp.Event.Each
Udp.Send can optionally request a positive acknowledgment to be sent
to the commanding actor.Default
Udp.NoAck instance which is used when no acknowledgment information is
explicitly provided.When a listener actor receives a datagram from its socket it will send
it to the handler designated in the
Udp.Bind message using this message type.This message must be sent to the listener actor to re-enable reading from
the socket after a
SuspendReading command.This message is understood by the “simple sender” which can be obtained by
sending the
Udp.SimpleSender query to the UdpExt.manager() as well as by
the listener actors which are created in response to Udp.Bind.Retrieve a reference to a “simple sender” actor of the UDP extension.
The “simple sender” sends this message type in response to a
Udp.SimpleSender query.Scala API: This object provides access to all socket options applicable to UDP sockets.
Send this message to a listener actor (which sent a
Udp.Bound message) to
have it stop reading datagrams from the network.Send this message to the listener actor that previously sent a
Udp.Bound
message in order to close the listening socket.This message is sent by the listener actor in response to an
Unbind command
after the socket has been closed.UDP Extension for Akka’s IO layer.
UDP Extension for Akka’s IO layer.
The common type of all commands supported by the UDP implementation.
When a command fails it will be replied to with this message type,
wrapping the failing command object.
Send this message to the
UdpExt.manager() in order to bind to a local
port (optionally with the chosen localAddress) and create a UDP socket
which is restricted to sending to and receiving from the given remoteAddress.This message is sent by the connection actor to the actor which sent the
UdpConnected.Connect message when the UDP socket has been bound to the local and
remote addresses given.Send this message to a connection actor (which had previously sent the
UdpConnected.Connected message) in order to close the socket.This message is sent by the connection actor to the actor which sent the
Disconnect message when the UDP socket has been closed.The common type of all events emitted by the UDP implementation.
The common interface for
UdpConnected.Command and UdpConnected.Event.Each
UdpConnected.Send can optionally request a positive acknowledgment to be sent
to the commanding actor.Default
UdpConnected.NoAck instance which is used when no acknowledgment information is
explicitly provided.When a connection actor receives a datagram from its socket it will send
it to the handler designated in the
Udp.Bind message using this message type.This message must be sent to the listener actor to re-enable reading from
the socket after a
SuspendReading command.This message is understood by the connection actors to send data to their
designated destination.
Send this message to a listener actor (which sent a
Udp.Bound message) to
have it stop reading datagrams from the network.UDP Extension for Akka’s IO layer.
Java API: factory methods for the message types used when communicating with the UdpConnected service.
Java API: factory methods for the message types used when communicating with the UdpConnected service.
Java API: factory methods for the message types used when communicating with the Udp service.
Java API: factory methods for the message types used when communicating with the Udp service.
UnboundedControlAwareMailbox is an unbounded MailboxType, that maintains two queues
to allow messages that extend
pekko.dispatch.ControlMessage to be delivered with priority.UnboundedDequeBasedMailbox is an unbounded MailboxType, backed by a Deque.
UnboundedDequeBasedMessageQueueSemantics adds unbounded semantics to a DequeBasedMessageQueue,
i.e.
UnboundedMailbox is the default unbounded MailboxType used by Pekko Actors.
UnboundedMessageQueueSemantics adds unbounded semantics to a QueueBasedMessageQueue,
i.e.
UnboundedPriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.
UnboundedStablePriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.
The
UnboundedStash trait is a version of pekko.actor.Stash that enforces an unbounded stash for you actor.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
This message is published to the EventStream whenever an Actor receives a message it doesn't understand
A stream interpreter that was not yet initialized when the snapshot was taken
Member identifier consisting of address and random
uid.A
UniqueKillSwitch is always a result of a materialization (unlike SharedKillSwitch which is constructed
before any materialization) and it always controls that graph and operator which yielded the materialized value.Version of
PartialFunction that can be built during runtime from Java.A builder for
PartialFunction.INTERNAL API
Message sent when LogService is unregistered.
Message sent when LogService is unregistered.
A version of
pekko.actor.Stash that does not enforce any mailbox type.INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
INTERNAL API
Explicitly unsubscribe from client interaction events.
Explicitly unsubscribe from contact point change events.
If the validation of the
ReceiveBuilder match logic turns out to be a bottleneck for some of your
actors you can consider to implement it at lower level by extending UntypedAbstractActor instead
of AbstractActor.Java API: compatible with lambda expressions
Java API: Support for scheduled
self messages via TimerScheduler.Java API: compatible with lambda expressions
Java API: compatible with lambda expressions
Java API: compatible with lambda expressions
Takes a stream of pair elements and splits each pair to two output streams.
Takes a stream of pair elements and splits each pair to two output streams.
Takes a stream of pair elements and splits each pair to two output streams.
Takes a stream of pair elements and splits each pair to two output streams.
Split one stream into several streams using a splitting function.
Transforms each element of input stream into multiple streams using a splitter function.
Split one stream into several streams using a splitting function.
Transforms each element of input stream into multiple streams using a splitter function.
`UnzipWith` specialized for 10 outputs
`UnzipWith` specialized for 11 outputs
`UnzipWith` specialized for 12 outputs
`UnzipWith` specialized for 13 outputs
`UnzipWith` specialized for 14 outputs
`UnzipWith` specialized for 15 outputs
`UnzipWith` specialized for 16 outputs
`UnzipWith` specialized for 17 outputs
`UnzipWith` specialized for 18 outputs
`UnzipWith` specialized for 19 outputs
`UnzipWith` specialized for 2 outputs
`UnzipWith` specialized for 20 outputs
`UnzipWith` specialized for 21 outputs
`UnzipWith` specialized for 22 outputs
`UnzipWith` specialized for 3 outputs
`UnzipWith` specialized for 4 outputs
`UnzipWith` specialized for 5 outputs
`UnzipWith` specialized for 6 outputs
`UnzipWith` specialized for 7 outputs
`UnzipWith` specialized for 8 outputs
`UnzipWith` specialized for 9 outputs
UnzipWithApply.UnzipWithCreator18<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18>
UnzipWithApply.UnzipWithCreator19<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19>
UnzipWithApply.UnzipWithCreator20<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20>
UnzipWithApply.UnzipWithCreator21<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21>
UnzipWithApply.UnzipWithCreator22<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21,A22>
param: persistenceId The persistence id of the origin entity.
This class hold common utilities for Java
This class hold common utilities for Java
Scala implementation of UUIDComparator in
https://github.com/cowtowncoder/java-uuid-generator
Apache License 2.0.
VectorClock module with helper classes and methods.
Comparable version information.
INTERNAL API
INTERNAL API
Representation of a Vector-based clock (counting clock), inspired by Lamport logical clocks.
INTERNAL API
VersionVector module with helper classes and methods.
INTERNAL API
A virtualized executor service that creates a new virtual thread for each task.
A time source.
Filter which matches Warning events, if they satisfy the given criteria:
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either with String.startsWith or Regex.findFirstIn().isDefined)
If you want to match all Warning events, the most efficient is to use Left("").Used as failure exception by an
ask operator if the target actor terminates.Protobuf type
AckAndEnvelopeContainerProtobuf type
AckAndEnvelopeContainerProtobuf type
AcknowledgementInfoProtobuf type
AcknowledgementInfo
*
Defines a remote ActorRef that "remembers" and uses its original Actor instance
on the original node.
*
Defines a remote ActorRef that "remembers" and uses its original Actor instance
on the original node.
*
Defines a remote address.
*
Defines a remote address.
*
Defines the type of the PekkoControlMessage command type
*
Defines org.apache.pekko.remote.DaemonMsgCreate
*
Defines org.apache.pekko.remote.DaemonMsgCreate
Protobuf type
DefaultResizerProtobuf type
DefaultResizer
*
Serialization of org.apache.pekko.actor.Deploy
*
Serialization of org.apache.pekko.actor.Deploy
Protobuf type
FiniteDurationProtobuf type
FiniteDurationProtobuf type
FromConfigProtobuf type
FromConfigProtobuf type
GenericRoutingPoolProtobuf type
GenericRoutingPool
*
Defines some control messages for the remoting
*
Defines some control messages for the remoting
Protobuf type
PekkoHandshakeInfoProtobuf type
PekkoHandshakeInfo
*
Message format of Pekko Protocol.
*
Message format of Pekko Protocol.
*
Serialization of org.apache.pekko.actor.Props
*
Serialization of org.apache.pekko.actor.Props
*
Defines a remote message.
*
Defines a remote message.
Protobuf type
RemoteRouterConfigProtobuf type
RemoteRouterConfigProtobuf type
RemoteScopeProtobuf type
RemoteScopeProtobuf type
ScatterGatherPoolProtobuf type
ScatterGatherPool
*
Defines a message.
*
Defines a message.
Protobuf type
TailChoppingPoolProtobuf type
TailChoppingPool
*
java.util.concurrent.TimeUnit enum
Fan-out the stream to two output streams - a 'main' and a 'tap' one.
Fan-out the stream to two output streams - a 'main' and a 'tap' one.
INTERNAL API
INTERNAL API
Work pulling is a pattern where several worker actors pull tasks in their own pace from
a shared work manager instead of that the manager pushes work to the workers blindly
without knowing their individual capacity and current availability.
Retrieve information about registered workers.
For sending confirmation message back to the producer when the message has been fully delivered, processed,
and confirmed by the consumer.
The
WorkPullingProducerController sends RequestNext to the producer when it is allowed to send one
message via the sendNextTo or askNextTo.Initial message from the producer actor.
Work pulling is a pattern where several worker actors pull tasks in their own pace from
a shared work manager instead of that the manager pushes work to the workers blindly
without knowing their individual capacity and current availability.
For commands defined in public WorkPullingProducerController
INTERNAL API
Message envelopes may implement this trait for better logging, such as logging of
message class name of the wrapped message instead of the envelope class name.
INTERNAL API
Facility to convert to specialised data models, as may be required by specialized persistence Journals.
Write in journal operation with events to be written.
Storage write operation to persist snapshot in the storage.
INTERNAL API
INTERNAL API
Combine the elements of 2 streams into a stream of tuples.
Combine the elements of 2 streams into a stream of tuples.
Combine the elements of 2 streams into a stream of tuples.
Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
`ZipLatestWith` specialized for 10 inputs
`ZipLatestWith` specialized for 11 inputs
`ZipLatestWith` specialized for 12 inputs
`ZipLatestWith` specialized for 13 inputs
`ZipLatestWith` specialized for 14 inputs
`ZipLatestWith` specialized for 15 inputs
`ZipLatestWith` specialized for 16 inputs
`ZipLatestWith` specialized for 17 inputs
`ZipLatestWith` specialized for 18 inputs
`ZipLatestWith` specialized for 19 inputs
`ZipLatestWith` specialized for 2 inputs
`ZipLatestWith` specialized for 20 inputs
`ZipLatestWith` specialized for 21 inputs
`ZipLatestWith` specialized for 22 inputs
`ZipLatestWith` specialized for 3 inputs
`ZipLatestWith` specialized for 4 inputs
`ZipLatestWith` specialized for 5 inputs
`ZipLatestWith` specialized for 6 inputs
`ZipLatestWith` specialized for 7 inputs
`ZipLatestWith` specialized for 8 inputs
`ZipLatestWith` specialized for 9 inputs
Combine the elements of multiple streams into a stream of lists.
Combine the elements of multiple streams into a stream of sequences.
Combine the elements of multiple streams into a stream of lists.
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
`ZipWith` specialized for 10 inputs
`ZipWith` specialized for 11 inputs
`ZipWith` specialized for 12 inputs
`ZipWith` specialized for 13 inputs
`ZipWith` specialized for 14 inputs
`ZipWith` specialized for 15 inputs
`ZipWith` specialized for 16 inputs
`ZipWith` specialized for 17 inputs
`ZipWith` specialized for 18 inputs
`ZipWith` specialized for 19 inputs
`ZipWith` specialized for 2 inputs
`ZipWith` specialized for 20 inputs
`ZipWith` specialized for 21 inputs
`ZipWith` specialized for 22 inputs
`ZipWith` specialized for 3 inputs
`ZipWith` specialized for 4 inputs
`ZipWith` specialized for 5 inputs
`ZipWith` specialized for 6 inputs
`ZipWith` specialized for 7 inputs
`ZipWith` specialized for 8 inputs
`ZipWith` specialized for 9 inputs
Combine the elements of multiple streams into a stream of lists using a combiner function.
Combine the elements of multiple streams into a stream of sequences using a combiner function.
Combine the elements of multiple streams into a stream of lists using a combiner function.