akka.remote

Class RemoteWatcher

java.lang.Object

akka.remote.RemoteWatcher

All Implemented Interfaces:

Actor, ActorLogging, RequiresMessageQueue<UnboundedMessageQueueSemantics>

Direct Known Subclasses:

ClusterRemoteWatcher

public class RemoteWatcher
extends java.lang.Object
implements Actor, ActorLogging, RequiresMessageQueue<UnboundedMessageQueueSemantics>

INTERNAL API

Remote nodes with actors that are watched are monitored by this actor to be able to detect network failures and JVM crashes. RemoteActorRefProvider intercepts Watch and Unwatch system messages and sends corresponding RemoteWatcher.WatchRemote and RemoteWatcher.UnwatchRemote to this actor.

For a new node to be watched this actor periodically sends RemoteWatcher.Heartbeat to the peer actor on the other node, which replies with RemoteWatcher.HeartbeatRsp message back. The failure detector on the watching side monitors these heartbeat messages. If arrival of heartbeat messages stops it will be detected and this actor will publish AddressTerminated to the AddressTerminatedTopic.

When all actors on a node have been unwatched it will stop sending heartbeat messages.

For bi-directional watch between two nodes the same thing will be established in both directions, but independent of each other.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	RemoteWatcher.ArteryHeartbeat$
static class	RemoteWatcher.ArteryHeartbeatRsp
static class	RemoteWatcher.ArteryHeartbeatRsp$
static class	RemoteWatcher.ExpectedFirstHeartbeat
static class	RemoteWatcher.ExpectedFirstHeartbeat$
static class	RemoteWatcher.Heartbeat$
static class	RemoteWatcher.HeartbeatRsp
static class	RemoteWatcher.HeartbeatRsp$
static class	RemoteWatcher.HeartbeatTick$
static class	RemoteWatcher.ReapUnreachableTick$
static class	RemoteWatcher.Stats
static class	RemoteWatcher.Stats$
static class	RemoteWatcher.UnwatchRemote
static class	RemoteWatcher.UnwatchRemote$
static class	RemoteWatcher.WatchRemote
static class	RemoteWatcher.WatchRemote$

Nested classes/interfaces inherited from interface akka.actor.Actor

Actor.emptyBehavior$, Actor.ignoringBehavior$

Constructor Summary

Constructors

Constructor and Description
RemoteWatcher(FailureDetectorRegistry<Address> failureDetector, scala.concurrent.duration.FiniteDuration heartbeatInterval, scala.concurrent.duration.FiniteDuration unreachableReaperInterval, scala.concurrent.duration.FiniteDuration heartbeatExpectedResponseAfter)

Method Summary

Modifier and Type	Method and Description
scala.collection.immutable.Map<Address,java.lang.Object>	addressUids()
void	addWatch(InternalActorRef watchee, InternalActorRef watcher)
protected abstract static void	akka$actor$Actor$_setter_$context_$eq(ActorContext x$1)
protected abstract static void	akka$actor$Actor$_setter_$self_$eq(ActorRef x$1)
static void	akka$actor$ActorLogging$$_log_$eq(LoggingAdapter x$1)
static LoggingAdapter	akka$actor$ActorLogging$$_log()
protected static void	aroundPostRestart(java.lang.Throwable reason)
protected static void	aroundPostStop()
protected static void	aroundPreRestart(java.lang.Throwable reason, scala.Option<java.lang.Object> message)
protected static void	aroundPreStart()
protected static void	aroundReceive(scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive, java.lang.Object msg)
boolean	artery()
ActorContext	context() Stores the context for this actor, including self, and sender.
Cancellable	failureDetectorReaperTask()
HeartbeatMessage	heartBeatMsg()
Cancellable	heartbeatTask()
static LoggingAdapter	log()
static void	postRestart(java.lang.Throwable reason)
void	postStop() User overridable callback.
static void	preRestart(java.lang.Throwable reason, scala.Option<java.lang.Object> message)
static void	preStart()
static Props	props(FailureDetectorRegistry<Address> failureDetector, scala.concurrent.duration.FiniteDuration heartbeatInterval, scala.concurrent.duration.FiniteDuration unreachableReaperInterval, scala.concurrent.duration.FiniteDuration heartbeatExpectedResponseAfter) Factory method for RemoteWatcher Props.
void	publishAddressTerminated(Address address)
void	quarantine(Address address, scala.Option<java.lang.Object> uid, java.lang.String reason)
void	reapUnreachable()
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	receive() This defines the initial actor behavior, it must return a partial function with the actor logic.
void	receiveHeartbeat()
void	receiveHeartbeatRsp(long uid)
RemoteActorRefProvider	remoteProvider()
void	removeWatch(InternalActorRef watchee, InternalActorRef watcher)
void	removeWatchee(InternalActorRef watchee)
void	reWatch(Address address) To ensure that we receive heartbeat messages from the right actor system incarnation we send Watch again for the first HeartbeatRsp (containing the system UID) and if HeartbeatRsp contains a new system UID.
Scheduler	scheduler()
ActorRef	self() The 'self' field holds the ActorRef for this actor.
HeartbeatMessage	selfHeartbeatRspMsg()
static ActorRef	sender()
void	sendHeartbeat()
static SupervisorStrategy	supervisorStrategy()
void	terminated(InternalActorRef watchee, boolean existenceConfirmed, boolean addressTerminated)
void	triggerFirstHeartbeat(Address address)
static void	unhandled(java.lang.Object message)
scala.collection.immutable.Set<Address>	unreachable()
void	unwatchNode(Address watcheeAddress)
scala.collection.mutable.HashMap<Address,scala.collection.mutable.Set<InternalActorRef>>	watcheeByNodes()
scala.collection.mutable.HashMap<InternalActorRef,scala.collection.mutable.Set<InternalActorRef>>	watching()
scala.collection.Set<Address>	watchingNodes()
void	watchNode(InternalActorRef watchee)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface akka.actor.Actor

aroundPostRestart, aroundPostStop, aroundPreRestart, aroundPreStart, aroundReceive, postRestart, preRestart, preStart, sender, supervisorStrategy, unhandled

Methods inherited from interface akka.actor.ActorLogging

log

Constructor Detail

RemoteWatcher

public RemoteWatcher(FailureDetectorRegistry<Address> failureDetector,
                     scala.concurrent.duration.FiniteDuration heartbeatInterval,
                     scala.concurrent.duration.FiniteDuration unreachableReaperInterval,
                     scala.concurrent.duration.FiniteDuration heartbeatExpectedResponseAfter)

Method Detail

props

public static Props props(FailureDetectorRegistry<Address> failureDetector,
                          scala.concurrent.duration.FiniteDuration heartbeatInterval,
                          scala.concurrent.duration.FiniteDuration unreachableReaperInterval,
                          scala.concurrent.duration.FiniteDuration heartbeatExpectedResponseAfter)

Factory method for RemoteWatcher Props.

Parameters:

failureDetector - (undocumented)

heartbeatInterval - (undocumented)

unreachableReaperInterval - (undocumented)

heartbeatExpectedResponseAfter - (undocumented)

Returns:

(undocumented)

sender

public static final ActorRef sender()

aroundReceive

protected static void aroundReceive(scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive,
                                    java.lang.Object msg)

aroundPreStart

protected static void aroundPreStart()

aroundPostStop

protected static void aroundPostStop()

aroundPreRestart

protected static void aroundPreRestart(java.lang.Throwable reason,
                                       scala.Option<java.lang.Object> message)

aroundPostRestart

protected static void aroundPostRestart(java.lang.Throwable reason)

supervisorStrategy

public static SupervisorStrategy supervisorStrategy()

preStart

public static void preStart()
                     throws java.lang.Exception

Throws:

java.lang.Exception

preRestart

public static void preRestart(java.lang.Throwable reason,
                              scala.Option<java.lang.Object> message)
                       throws java.lang.Exception

Throws:

java.lang.Exception

postRestart

public static void postRestart(java.lang.Throwable reason)
                        throws java.lang.Exception

Throws:

java.lang.Exception

unhandled

public static void unhandled(java.lang.Object message)

akka$actor$Actor$_setter_$context_$eq

protected abstract static void akka$actor$Actor$_setter_$context_$eq(ActorContext x$1)

akka$actor$Actor$_setter_$self_$eq

protected abstract static void akka$actor$Actor$_setter_$self_$eq(ActorRef x$1)

akka$actor$ActorLogging$$_log

public static LoggingAdapter akka$actor$ActorLogging$$_log()

akka$actor$ActorLogging$$_log_$eq

public static void akka$actor$ActorLogging$$_log_$eq(LoggingAdapter x$1)

log

public static LoggingAdapter log()

context

public ActorContext context()

Description copied from interface: Actor

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!

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

Specified by:

context in interface Actor

Returns:

(undocumented)

self

public final ActorRef self()

Description copied from interface: Actor

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

Can be used to send messages to itself:

 self ! message
 

Specified by:

self in interface Actor

Returns:

(undocumented)

scheduler

public Scheduler scheduler()

remoteProvider

public RemoteActorRefProvider remoteProvider()

artery

public boolean artery()

heartBeatMsg

public HeartbeatMessage heartBeatMsg()

selfHeartbeatRspMsg

public HeartbeatMessage selfHeartbeatRspMsg()

watching

public scala.collection.mutable.HashMap<InternalActorRef,scala.collection.mutable.Set<InternalActorRef>> watching()

watcheeByNodes

public scala.collection.mutable.HashMap<Address,scala.collection.mutable.Set<InternalActorRef>> watcheeByNodes()

watchingNodes

public scala.collection.Set<Address> watchingNodes()

unreachable

public scala.collection.immutable.Set<Address> unreachable()

addressUids

public scala.collection.immutable.Map<Address,java.lang.Object> addressUids()

heartbeatTask

public Cancellable heartbeatTask()

failureDetectorReaperTask

public Cancellable failureDetectorReaperTask()

postStop

public void postStop()

Description copied from interface: Actor

User overridable callback.

Is called asynchronously after 'actor.stop()' is invoked. Empty default implementation.

Specified by:

postStop in interface Actor

receive

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive()

Description copied from interface: Actor

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

Specified by:

receive in interface Actor

Returns:

(undocumented)

receiveHeartbeat

public void receiveHeartbeat()

receiveHeartbeatRsp

public void receiveHeartbeatRsp(long uid)

reapUnreachable

public void reapUnreachable()

publishAddressTerminated

public void publishAddressTerminated(Address address)

quarantine

public void quarantine(Address address,
                       scala.Option<java.lang.Object> uid,
                       java.lang.String reason)

addWatch

public void addWatch(InternalActorRef watchee,
                     InternalActorRef watcher)

watchNode

public void watchNode(InternalActorRef watchee)

removeWatch

public void removeWatch(InternalActorRef watchee,
                        InternalActorRef watcher)

removeWatchee

public void removeWatchee(InternalActorRef watchee)

unwatchNode

public void unwatchNode(Address watcheeAddress)

terminated

public void terminated(InternalActorRef watchee,
                       boolean existenceConfirmed,
                       boolean addressTerminated)

sendHeartbeat

public void sendHeartbeat()

triggerFirstHeartbeat

public void triggerFirstHeartbeat(Address address)

reWatch

public void reWatch(Address address)

To ensure that we receive heartbeat messages from the right actor system incarnation we send Watch again for the first HeartbeatRsp (containing the system UID) and if HeartbeatRsp contains a new system UID. Terminated will be triggered if the watchee (including correct Actor UID) does not exist.

Parameters:

address - (undocumented)