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

View id is used as identifier for snapshots performed by this PersistentView. This allows the View to keep separate snapshots of data than the PersistentActor originating the message stream.

The usual case is to have a *different* id set as viewId than persistenceId, although it is possible to share the same id with an PersistentActor - for example to decide about snapshots based on some average or sum, calculated by this view.

Example:

class SummingView extends PersistentView {
  override def persistenceId = "count-123"
  override def viewId        = "count-123-sum" // this view is performing summing,
                                               // so this view's snapshots reside under the "-sum" suffixed id

  // ...
}

Can be overridden to intercept calls to postRestart. Calls postRestart by default.

Can be overridden to intercept calls to postStop. Calls postStop by default.

Can be overridden to intercept calls to preRestart. Calls preRestart by default.

INTERNAL API.

INTERNAL API.

If true, this view automatically updates itself with an interval specified by autoUpdateInterval. If false, applications must explicitly update this view by sending Update requests. The default value can be configured with the akka.persistence.view.auto-update configuration key. This method can be overridden by implementation classes to return non-default values.

The interval for automated updates. The default value can be configured with the akka.persistence.view.auto-update-interval configuration key. This method can be overridden by implementation classes to return non-default values.

The maximum number of messages to replay per update. The default value can be configured with the akka.persistence.view.auto-update-replay-max configuration key. This method can be overridden by implementation classes to return non-default values.

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.

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.

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

If true, the currently processed message was persisted (is sent from the Journal). If false, the currently processed message comes from another actor (from "user-land").

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 any persistent events yet.

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

Called whenever a message replay fails. By default it logs the error. Subclass may override to customize logging. The PersistentView will not stop or throw exception due to this. It will try again on next update.

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.

Triggers an initial recovery, starting form a snapshot, if any, and replaying at most autoUpdateReplayMax messages (following that snapshot).

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.

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!

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

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().