Java API for ExtensionId
Actor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model': http://en.wikipedia.org/wiki/Actor_model
The actor context - the view of the actor cell from the actor.
Reply to akka.actor.Identify.
An ActorInitializationException is thrown when the 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 akka.actor.Kill message
Scala API: Mix in ActorLogging into your Actor to easily obtain a reference to a logger, which is available under the name "log".
When ActorSelection#resolveOne 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.
Immutable and serializable handle to an actor, which may or may not reside on the local host or inside the same akka.actor.ActorSystem.
Interface implemented by ActorSystem and ActorContext, the only two places from which you can get fresh actors.
Interface for all ActorRef providers to implement.
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 actor system is a hierarchical group of actors which share common configuration, e.
The address specifies the physical location under which an Actor can be reached.
Applies the fault handling Directive
(Resume, Restart, Stop) specified in the Decider
to all children when one fails, as opposed to akka.actor.OneForOneStrategy that applies
it only to the child actor that failed.
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.
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.
ContextualTypedActorFactory allows TypedActors to create children, effectively forming the same Actor Supervision Hierarchies as normal Actors can.
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
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.
This class represents deployment configuration for a given actor path.
The DynamicAccess implementation is the class which is used for loading all configurable parts of an actor system (the akka.actor.ReflectiveDynamicAccess is the default implementation).
More powerful interface to the actor system’s implementation which is presented to extensions (see akka.actor.Extension).
The basic ActorSystem covers all that is needed for locally running actors, using futures and so on.
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.
To be able to load an ExtensionId from the configuration, a class that implements ExtensionIdProvider must be specified.
This is a one-stop-shop if all you want is an extension which is constructed with the ExtendedActorSystem as its only constructor argument:
Finite State Machine actor trait.
IOManager contains a reference to the akka.actor.IOManagerActor for an akka.actor.ActorSystem.
An akka.actor.Actor that performs IO using a Java NIO Selector.
A message all Actors will understand, that when processed will reply with
akka.actor.ActorIdentity containing the ActorRef
.
IllegalActorStateException is thrown when a core invariant in the Actor implementation has been violated.
An Inbox is an actor-like object which is interrogated from the outside.
This interface defines a class of actor creation strategies deviating from the usual default of just reflectively instantiating the Actor subclass.
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.
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.
Stackable trait for akka.actor.FSM which adds a rolling event log and debug logging capabilities (analogous to akka.event.LoggingReceive).
This is the default value and as such allows overrides.
Marker trait to signal that this class should not be verified for serializability.
Applies the fault handling Directive
(Resume, Restart, Stop) specified in the Decider
to the child actor that failed, as opposed to akka.actor.AllForOneStrategy that applies
it to all children.
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.
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.
Props is a configuration object using in creating an Actor; it is immutable, so it is thread-safe and fully shareable.
This is the default akka.actor.DynamicAccess implementation used by akka.actor.ExtendedActorSystem unless overridden.
Root of the hierarchy of ActorPaths.
This trait represents the Scala Actor API There are implicit conversions in .
Contains the Scala API (!-method) for ActorSelections) which provides automatic tracking of the sender, as per the usual implicit ActorRef pattern.
An Akka scheduler service.
The scope of a akka.actor.Deploy serves two purposes: as a marker for pattern matching the “scope” (i.
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.
Is thrown when the size of the Stash exceeds the capacity of the Stash
An Akka SupervisorStrategy is the policy to apply for crashing children.
Implement this interface in order to configure the supervisorStrategy for
the top-level guardian actor (/user
).
When Death Watch is used, the watcher will receive a Terminated(watched) message when watched is terminated.
A TypedActorFactory is something that can created TypedActor instances.
TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.
The UnboundedStash
trait is a version of akka.actor.Stash that enforces an unbounded stash for you actor.
This message is published to the EventStream whenever an Actor receives a message it doesn't understand
A version of akka.actor.Stash that does not enforce any mailbox type.
Actor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model': http://en.wikipedia.org/wiki/Actor_model
UntypedActorContext is the UntypedActor equivalent of ActorContext, containing the Java API
Actor base class that should be extended to create an actor with a stash.
Actor base class with Stash
that enforces an unbounded deque for the actor.
Actor base class with Stash
that does not enforce any mailbox type.
A scheduler implementation based on a HashedWheelTimer.
Factory closure for an UntypedActor, to be used with 'Actors.
This object contains elements which make writing actors and related code more concise, e.
Given an ActorPath it returns the Address and the path elements if the path is well-formed
An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors, allowing for broadcasting of messages to that section.
This object serves as extractor for Scala and as address parser for Java.
A message all Actors will understand, that when processed will make the Actor throw an ActorKilledException, which will trigger supervision.
The Local Scope is the default one, which is assumed on all deployments which do not set a different scope.
This is an extractor for retrieving the original cause (i.
A message all Actors will understand, that when processed will terminate the Actor permanently.
Factory for Props instances.
When using ActorContext.
Extractor for so-called “relative actor paths” as in “relative URI”, not in “relative to some actor”.
Classes for passing status back to the sender.
This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.
TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.
IO messages and iteratees.