Id of the persistent entity for which messages should be replayed.

Command handler. Typically validates commands against current state (and/or by communication with other actors). On successful validation, one or more events are derived from a command and these events are then persisted by calling persist.

Recovery handler that receives persisted events during recovery. If a state snapshot has been captured and saved, this handler will receive a SnapshotOffer message followed by events that are younger than the offered snapshot.

This handler must not have side-effects other than changing persistent actor state i.e. it should not perform actions that may fail, such as interacting with external services, for example.

If there is a problem with recovering the state of the actor from the journal, the error will be logged and the actor will be stopped.

INTERNAL API.

INTERNAL API

INTERNAL API

INTERNAL API.

INTERNAL API

Call this method when a message has been confirmed by the destination, or to abort re-sending.

Stores the context for this actor, including self, and sender. It is implicit to support operations such as forward.

WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!

akka.actor.ActorContext is the Scala API. getContext returns a akka.actor.UntypedActorContext, which is the Java API of the actor context.

Defer the handler execution until all pending handlers have been executed. Allows to define logic within the actor, which will respect the invocation-order-guarantee in respect to persistAsync calls. That is, if persistAsync was invoked before defer, the corresponding handlers will be invoked in the same order as they were registered in.

This call will NOT result in event being persisted, please use persist or persistAsync, if the given event should possible to replay.

If there are no pending persist handler calls, the handler will be called immediately.

If persistence of an earlier event fails, the persistent actor will stop, and the handler will not be run.

Defer the handler execution until all pending handlers have been executed. Allows to define logic within the actor, which will respect the invocation-order-guarantee in respect to persistAsync calls. That is, if persistAsync was invoked before deferAsync, the corresponding handlers will be invoked in the same order as they were registered in.

This call will NOT result in event being persisted, use persist or persistAsync instead if the given event should possible to replay.

If there are no pending persist handler calls, the handler will be called immediately.

If persistence of an earlier event fails, the persistent actor will stop, and the handler will not be run.

Permanently deletes all persistent messages with sequence numbers less than or equal toSequenceNr.

If the delete is successful a DeleteMessagesSuccess will be sent to the actor. If the delete fails a DeleteMessagesFailure will be sent to the actor.

Deletes the snapshot identified by sequenceNr.

The PersistentActor will be notified about the status of the deletion via an DeleteSnapshotSuccess or DeleteSnapshotFailure message.

Deletes all snapshots matching criteria.

The PersistentActor will be notified about the status of the deletion via an DeleteSnapshotsSuccess or DeleteSnapshotsFailure message.

Java API: Send the message created by the deliveryIdToMessage function to the destination actor. It will retry sending the message until the delivery is confirmed with #confirmDelivery. Correlation between deliver and confirmDelivery is performed with the deliveryId that is provided as parameter to the deliveryIdToMessage function. The deliveryId is typically passed in the message to the destination, which replies with a message containing the same deliveryId.

The deliveryId is a strictly monotonically increasing sequence number without gaps. The same sequence is used for all destinations, i.e. when sending to multiple destinations the destinations will see gaps in the sequence if no translation is performed.

During recovery this method will not send out the message, but it will be sent later if no matching confirmDelivery was performed.

This method will throw AtLeastOnceDelivery.MaxUnconfirmedMessagesExceededException if #numberOfUnconfirmed is greater than or equal to #maxUnconfirmedMessages.

Java API: Send the message created by the deliveryIdToMessage function to the destination actor. It will retry sending the message until the delivery is confirmed with #confirmDelivery. Correlation between deliver and confirmDelivery is performed with the deliveryId that is provided as parameter to the deliveryIdToMessage function. The deliveryId is typically passed in the message to the destination, which replies with a message containing the same deliveryId.

The deliveryId is a strictly monotonically increasing sequence number without gaps. The same sequence is used for all destinations, i.e. when sending to multiple destinations the destinations will see gaps in the sequence if no translation is performed.

During recovery this method will not send out the message, but it will be sent later if no matching confirmDelivery was performed.

This method will throw AtLeastOnceDelivery.MaxUnconfirmedMessagesExceededException if #numberOfUnconfirmed is greater than or equal to #maxUnconfirmedMessages.

Scala API: Send the message created by the deliveryIdToMessage function to the destination actor. It will retry sending the message until the delivery is confirmed with #confirmDelivery. Correlation between deliver and confirmDelivery is performed with the deliveryId that is provided as parameter to the deliveryIdToMessage function. The deliveryId is typically passed in the message to the destination, which replies with a message containing the same deliveryId.

The deliveryId is a strictly monotonically increasing sequence number without gaps. The same sequence is used for all destinations of the actor, i.e. when sending to multiple destinations the destinations will see gaps in the sequence if no translation is performed.

During recovery this method will not send out the message, but it will be sent later if no matching confirmDelivery was performed.

This method will throw AtLeastOnceDelivery.MaxUnconfirmedMessagesExceededException if #numberOfUnconfirmed is greater than or equal to #maxUnconfirmedMessages.

Scala API: Send the message created by the deliveryIdToMessage function to the destination actor. It will retry sending the message until the delivery is confirmed with #confirmDelivery. Correlation between deliver and confirmDelivery is performed with the deliveryId that is provided as parameter to the deliveryIdToMessage function. The deliveryId is typically passed in the message to the destination, which replies with a message containing the same deliveryId.

The deliveryId is a strictly monotonically increasing sequence number without gaps. The same sequence is used for all destinations of the actor, i.e. when sending to multiple destinations the destinations will see gaps in the sequence if no translation is performed.

During recovery this method will not send out the message, but it will be sent later if no matching confirmDelivery was performed.

This method will throw AtLeastOnceDelivery.MaxUnconfirmedMessagesExceededException if #numberOfUnconfirmed is greater than or equal to #maxUnconfirmedMessages.

Returns this AbstractActor's AbstractActorContext The AbstractActorContext is not thread safe so do not expose it outside of the AbstractActor.

Full state of the AtLeastOnceDelivery. It can be saved with PersistentActor#saveSnapshot. During recovery the snapshot received in SnapshotOffer should be set with #setDeliverySnapshot.

The AtLeastOnceDeliverySnapshot contains the full delivery state, including unconfirmed messages. If you need a custom snapshot for other parts of the actor state you must also include the AtLeastOnceDeliverySnapshot. It is serialized using protobuf with the ordinary Akka serialization mechanism. It is easiest to include the bytes of the AtLeastOnceDeliverySnapshot as a blob in your custom snapshot.

The returned StashOverflowStrategy object determines how to handle the message failed to stash when the internal Stash capacity exceeded.

Configuration id of the journal plugin servicing this persistent actor or view. When empty, looks in akka.persistence.journal.plugin to find configuration entry path. When configured, uses journalPluginId as absolute path to the journal configuration entry. Configuration entry must contain few required fields, such as class. See src/main/resources/reference.conf.

Highest received sequence number so far or 0L if this actor hasn't replayed or stored any persistent events yet.

Instructs the snapshot store to load the specified snapshot and send it via an SnapshotOffer to the running PersistentActor.

Maximum number of unconfirmed messages that this actor is allowed to hold in memory. If this number is exceed #deliver will not accept more messages and it will throw AtLeastOnceDelivery.MaxUnconfirmedMessagesExceededException.

The default value can be configured with the akka.persistence.at-least-once-delivery.max-unconfirmed-messages configuration key. This method can be overridden by implementation classes to return non-default values.

Number of messages that have not been confirmed yet.

Called when persist fails. By default it logs the error. Subclass may override to customize logging and for example send negative acknowledgment to sender.

The actor is always stopped after this method has been invoked.

Note that the event may or may not have been saved, depending on the type of failure.

Called when the journal rejected persist of an event. The event was not stored. By default this method logs the problem as a warning, and the actor continues. The callback handler that was passed to the persist method will not be invoked.

Called whenever a message replay fails. By default it logs the error.

Subclass may override to customize logging.

The actor is always stopped after this method has been invoked.

Java API: asynchronously persists event. On successful persistence, handler is called with the persisted event. It is guaranteed that no new commands will be received by a persistent actor between a call to persist and the execution of its handler. This also holds for multiple persist calls per received command. Internally, this is achieved by stashing new commands and unstashing them when the event has been persisted and handled. The stash used for that is an internal stash which doesn't interfere with the inherited user stash.

An event handler may close over persistent actor state and modify it. The getSender() of a persisted event is the sender of the corresponding command. This means that one can reply to a command sender within an event handler.

Within an event handler, applications usually update persistent actor state using persisted event data, notify listeners and reply to command senders.

If persistence of an event fails, #onPersistFailure will be invoked and the actor will unconditionally be stopped. The reason that it cannot resume when persist fails is that it is unknown if the even was actually persisted or not, and therefore it is in an inconsistent state. Restarting on persistent failures will most likely fail anyway, since the journal is probably unavailable. It is better to stop the actor and after a back-off timeout start it again.

Asynchronously persists event. On successful persistence, handler is called with the persisted event. It is guaranteed that no new commands will be received by a persistent actor between a call to persist and the execution of its handler. This also holds for multiple persist calls per received command. Internally, this is achieved by stashing new commands and unstashing them when the event has been persisted and handled. The stash used for that is an internal stash which doesn't interfere with the inherited user stash.

An event handler may close over persistent actor state and modify it. The sender of a persisted event is the sender of the corresponding command. This means that one can reply to a command sender within an event handler.

Within an event handler, applications usually update persistent actor state using persisted event data, notify listeners and reply to command senders.

If persistence of an event fails, #onPersistFailure will be invoked and the actor will unconditionally be stopped. The reason that it cannot resume when persist fails is that it is unknown if the even was actually persisted or not, and therefore it is in an inconsistent state. Restarting on persistent failures will most likely fail anyway, since the journal is probably unavailable. It is better to stop the actor and after a back-off timeout start it again.

Java API: asynchronously persists events in specified order. This is equivalent to calling persist[A](event: A, handler: Procedure[A]) multiple times with the same handler, except that events are persisted atomically with this method.

Asynchronously persists events in specified order. This is equivalent to calling persist[A](event: A)(handler: A => Unit) multiple times with the same handler, except that events are persisted atomically with this method.

Java API: asynchronously persists events in specified order. This is equivalent to calling persistAsync[A](event: A)(handler: A => Unit) multiple times with the same handler, except that events are persisted atomically with this method.

Asynchronously persists events in specified order. This is equivalent to calling persistAsync[A](event: A)(handler: A => Unit) multiple times with the same handler, except that events are persisted atomically with this method.

Java API: asynchronously persists event. On successful persistence, handler is called with the persisted event.

Unlike persist the persistent actor will continue to receive incoming commands between the call to persistAsync and executing it's handler. This asynchronous, non-stashing, version of of persist should be used when you favor throughput over the strict ordering guarantees that persist guarantees.

If persistence of an event fails, #onPersistFailure will be invoked and the actor will unconditionally be stopped. The reason that it cannot resume when persist fails is that it is unknown if the even was actually persisted or not, and therefore it is in an inconsistent state. Restarting on persistent failures will most likely fail anyway, since the journal is probably unavailable. It is better to stop the actor and after a back-off timeout start it again.

Asynchronously persists event. On successful persistence, handler is called with the persisted event.

Unlike persist the persistent actor will continue to receive incoming commands between the call to persist and executing it's handler. This asynchronous, non-stashing, version of of persist should be used when you favor throughput over the "command-2 only processed after command-1 effects' have been applied" guarantee, which is provided by the plain persist method.

An event handler may close over persistent actor state and modify it. The sender of a persisted event is the sender of the corresponding command. This means that one can reply to a command sender within an event handler.

If persistence of an event fails, #onPersistFailure will be invoked and the actor will unconditionally be stopped. The reason that it cannot resume when persist fails is that it is unknown if the even was actually persisted or not, and therefore it is in an inconsistent state. Restarting on persistent failures will most likely fail anyway, since the journal is probably unavailable. It is better to stop the actor and after a back-off timeout start it again.

User overridable callback: By default it calls preStart().

Overridden callback. Prepends all messages in the stash to the mailbox and clears the stash. Must be called when overriding this method, otherwise stashed messages won't be propagated to DeadLetters when actor stops.

Overridden callback. Prepends all messages in the stash to the mailbox, clears the stash, stops all children and invokes the postStop() callback.

User overridable callback.

Is called when an Actor is started. Actors are automatically started asynchronously when created. Empty default implementation.

This defines the initial actor behavior, it must return a partial function with the actor logic.

Set up the initial receive behavior of the Actor.

Called when the persistent actor is started for the first time. The returned Recovery object defines how the Actor will recover its persistent state before handling the first incoming message.

To skip recovery completely return Recovery.none.

Returns true if this persistent actor has successfully finished recovery.

Returns true if this persistent actor is currently recovering.

Interval between redelivery attempts.

The default value can be configured with the akka.persistence.at-least-once-delivery.redeliver-interval configuration key. This method can be overridden by implementation classes to return non-default values.

Maximum number of unconfirmed messages that will be sent at each redelivery burst (burst frequency is half of the redelivery interval). If there's a lot of unconfirmed messages (e.g. if the destination is not available for a long time), this helps to prevent an overwhelming amount of messages to be sent at once.

The default value can be configured with the akka.persistence.at-least-once-delivery.redelivery-burst-limit configuration key. This method can be overridden by implementation classes to return non-default values.

Saves a snapshot of this snapshotter's state.

The PersistentActor will be notified about the success or failure of this via an SaveSnapshotSuccess or SaveSnapshotFailure message.

The 'self' field holds the ActorRef for this actor.

Can be used to send messages to itself:

self ! message

The reference sender Actor of the last received message. Is defined if the message was sent from another Actor, else deadLetters in akka.actor.ActorSystem.

WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!

If snapshot from #getDeliverySnapshot was saved it will be received during recovery in a SnapshotOffer message and should be set with this method.

Configuration id of the snapshot plugin servicing this persistent actor or view. When empty, looks in akka.persistence.snapshot-store.plugin to find configuration entry path. When configured, uses snapshotPluginId as absolute path to the snapshot store configuration entry. Configuration entry must contain few required fields, such as class. See src/main/resources/reference.conf.

Returns lastSequenceNr.

Returns persistenceId.

Adds the current message (the message that the actor received last) to the actor's stash.

User overridable definition the strategy to use for supervising child actors.

User overridable callback.

Is called when a message isn't handled by the current behavior of the actor by default it fails with either a akka.actor.DeathPactException (in case of an unhandled akka.actor.Terminated message) or publishes an akka.actor.UnhandledMessage to the actor's system's akka.event.EventStream

Prepends all messages in the stash to the mailbox, and then clears the stash.

Messages from the stash are enqueued to the mailbox until the capacity of the mailbox (if any) has been reached. In case a bounded mailbox overflows, a MessageQueueAppendFailedException is thrown.

The stash is guaranteed to be empty after calling unstashAll().

After this number of delivery attempts an AtLeastOnceDelivery.UnconfirmedWarning message will be sent to self. The count is reset after a restart.

The default value can be configured with the akka.persistence.at-least-once-delivery.warn-after-number-of-unconfirmed-attempts configuration key. This method can be overridden by implementation classes to return non-default values.