Package akka.cluster

Class CrossDcHeartbeatSender

  • All Implemented Interfaces:
    Actor, ActorLogging

    public final class CrossDcHeartbeatSender
    extends java.lang.Object
    implements Actor, ActorLogging
    INTERNAL API

    This actor is will be started on all nodes participating in a cluster, however unlike the within-dc heartbeat sender (ClusterHeartbeatSender), it will only actively work on n "oldest" nodes of a given data center.

    It will monitor it's oldest counterparts in other data centers. For example, a DC configured to have (up to) 4 monitoring actors, will have 4 such active at any point in time, and those will monitor the (at most) 4 oldest nodes of each data center.

    This monitoring mode is both simple and predictable, and also uses the assumption that "nodes which stay around for a long time, become old", and those rarely change. In a way, they are the "core" of a cluster, while other nodes may be very dynamically changing worked nodes which aggressively come and go as the traffic in the service changes.

    • Constructor Detail

      • CrossDcHeartbeatSender

        public CrossDcHeartbeatSender()
    • Method Detail

      • 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)
      • 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$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)
      • context

        public ActorContext context()
        Description copied from interface: Actor
        Scala API: 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 AbstractActor.ActorContext, 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)
      • akka$actor$Actor$_setter_$context_$eq

        protected void akka$actor$Actor$_setter_$context_$eq​(ActorContext x$1)
        Description copied from interface: Actor
        Scala API: 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 AbstractActor.ActorContext, which is the Java API of the actor context.

        Specified by:
        akka$actor$Actor$_setter_$context_$eq in interface Actor
        Parameters:
        x$1 - (undocumented)
      • akka$actor$Actor$_setter_$self_$eq

        protected final void akka$actor$Actor$_setter_$self_$eq​(ActorRef x$1)
        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:
        akka$actor$Actor$_setter_$self_$eq in interface Actor
        Parameters:
        x$1 - (undocumented)
      • cluster

        public Cluster cluster()
      • verboseHeartbeat

        public boolean verboseHeartbeat()
      • activelyMonitoring

        public boolean activelyMonitoring()
      • activelyMonitoring_$eq

        public void activelyMonitoring_$eq​(boolean x$1)
      • isExternalClusterMember

        public scala.Function1<Member,​java.lang.Object> isExternalClusterMember()
      • preStart

        public void preStart()
        Description copied from interface: Actor
        User overridable callback.

        Is called when an Actor is started. Actors are automatically started asynchronously when created. Empty default implementation.
        Specified by:
        preStart in interface Actor
      • 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
      • heartbeatReceiver

        public ActorSelection heartbeatReceiver​(Address address)
        Looks up and returns the remote cluster heartbeat connection for the specific address.
        Parameters:
        address - (undocumented)
        Returns:
        (undocumented)
      • receive

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> receive()
        Description copied from interface: Actor
        Scala API: This defines the initial actor behavior, it must return a partial function with the actor logic.
        Specified by:
        receive in interface Actor
        Returns:
        (undocumented)
      • dormant

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> dormant()
        In this state no cross-datacenter heartbeats are sent by this actor. This may be because one of those reasons: - no nodes in other DCs were detected yet - nodes in other DCs are present, but this node is not tht n-th oldest in this DC (see number-of-cross-datacenter-monitoring-actors), so it does not have to monitor that other data centers

        In this state it will however listen to cluster events to eventually take over monitoring other DCs in case it becomes "old enough".

        Returns:
        (undocumented)
      • active

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> active()
      • introspecting

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> introspecting()
      • addMember

        public void addMember​(Member m)
      • removeMember

        public void removeMember​(Member m)
      • heartbeat

        public void heartbeat()
      • heartbeatRsp

        public void heartbeatRsp​(UniqueAddress from)
      • triggerFirstHeartbeat

        public void triggerFirstHeartbeat​(UniqueAddress from)