The Receive block to run inside the coordinated transaction.
The Receive block to run inside the coordinated transaction. This is a function from InTxn to Receive block.
For example:
def atomically = implicit txn => { case Increment => count transform (_ + 1) }
A Receive block that runs after the coordinated transaction.
Default coordination - no other transactors.
Can be overridden to intercept calls to postRestart
.
Can be overridden to intercept calls to postStop
.
Can be overridden to intercept calls to preRestart
.
Can be overridden to intercept calls to preStart
.
INTERNAL API.
A Receive block that runs before the coordinated transaction is entered.
Stores the context for this actor, including self, and sender.
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.
Override this method to coordinate with other transactors.
Override this method to coordinate with other transactors. The other transactors are added to the coordinated transaction barrier and sent a Coordinated message. The message to send can be specified or otherwise the same message as received is sent. Use the 'include' and 'sendTo' methods to easily create the set of transactors to be involved.
Default catch-all for the different Receive methods.
Include other actors in this coordinated transaction and send them the same message as received.
Include other actors in this coordinated transaction and send them the same message as received. Use as the result in 'coordinated'.
Empty set of transactors to send to.
Bypass transactionality and behave like a normal actor.
User overridable callback: By default it calls preStart()
.
User overridable callback: By default it calls preStart()
.
the Throwable that caused the restart to happen
Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.
User overridable callback.
User overridable callback.
Is called asynchronously after 'actor.stop()' is invoked. Empty default implementation.
User overridable callback: By default it disposes of all children and then calls postStop()
.
User overridable callback: By default it disposes of all children and then calls postStop()
.
the Throwable that caused the restart to happen
optionally the current message the actor processed when failing, if applicable
Is called on a crashed Actor right BEFORE it is restarted to allow clean up of resources before Actor is terminated.
User overridable callback.
User overridable callback.
Is called when an Actor is started. Actors are automatically started asynchronously when created. Empty default implementation.
Implement a general pattern for using coordinated transactions.
Implement a general pattern for using coordinated transactions.
The 'self' field holds the ActorRef for this actor.
The 'self' field holds the ActorRef for this actor.
Can be used to send messages to itself:
self ! message
Include other actors in this coordinated transaction and specify the message to send by providing ActorRef -> Message pairs.
Include other actors in this coordinated transaction and specify the message to send by providing ActorRef -> Message pairs. Use as the result in 'coordinated'.
The reference sender Actor of the last received 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!
User overridable definition the strategy to use for supervising child actors.
User overridable definition the strategy to use for supervising child actors.
User overridable callback.
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
An actor with built-in support for coordinated transactions.
Transactors implement the general pattern for using akka.transactor.Coordinated where coordination messages are sent to other transactors then the coordinated transaction is entered. Transactors can also accept explicitly sent
Coordinated
messages.Simple transactors will just implement the
atomically
method which is similar to the actorreceive
method but runs within a coordinated transaction.Example of a simple transactor that will join a coordinated transaction:
To coordinate with other transactors override the
coordinate
method. Thecoordinate
method maps a message to a set of akka.transactor.SendTo objects, pairs ofActorRef
and a message. You can use theinclude
andsendTo
methods to easily coordinate with other transactors. Theinclude
method will send on the same message that was received to other transactors. ThesendTo
method allows you to specify both the actor to send to, and message to send.Example of coordinating an increment:
Using
include
to include more than one transactor:Using
sendTo
to coordinate transactions but send on a different message than the one that was received:To execute directly before or after the coordinated transaction, override the
before
andafter
methods. These methods also expect partial functions like the receive method. They do not execute within the transaction.To completely bypass coordinated transactions override the
normally
method. Any message matched bynormally
will not be matched by the other methods, and will not be involved in coordinated transactions. In this method you can implement normal actor behavior, or use the normal STM atomic for local transactions.(Since version 2.3) akka.transactor will be removed
akka.transactor.Coordinated