akka.contrib.pattern

Class ReliableProxy

java.lang.Object

akka.contrib.pattern.ReliableProxy

All Implemented Interfaces:

Actor, ActorLogging, FSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>, LoggingFSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>, ReliableProxyDebugLogging, Listeners

public class ReliableProxy
extends java.lang.Object
implements Actor, LoggingFSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>, ReliableProxyDebugLogging

A ReliableProxy is a means to wrap a remote actor reference in order to obtain certain improved delivery guarantees:

- as long as the proxy is not terminated before it sends all of its queued messages then no messages will be lost - messages re-sent due to the first point will not be delivered out-of-order, message ordering is preserved

These guarantees are valid for the communication between the two end-points of the reliable &ldquo;tunnel&rdquo;, which usually spans an unreliable network.

Note that the ReliableProxy guarantees at-least-once, not exactly-once, delivery.

Delivery from the remote end-point to the target actor is still subject to in-JVM delivery semantics (i.e. not strictly guaranteed due to possible OutOfMemory situations or other VM errors).

You can create a reliable connection like this:

In Scala:

 val proxy = context.actorOf(ReliableProxy.props(target, 100.millis, 120.seconds)
 

or in Java:

 final ActorRef proxy = getContext().actorOf(ReliableProxy.props(
   target, Duration.create(100, "millis"), Duration.create(120, "seconds")));
 

'''''Please note:''''' the tunnel is uni-directional, and original sender information is retained, hence replies by the wrapped target reference will go back in the normal &ldquo;unreliable&rdquo; way unless also secured by a ReliableProxy from the remote end.

==Message Types==

This actor is an FSM, hence it offers the service of transition callbacks to those actors which subscribe using the SubscribeTransitionCallBack and UnsubscribeTransitionCallBack messages; see FSM for more documentation. The proxy will transition into ReliableProxy.Active state when ACKs are outstanding and return to the ReliableProxy.Idle state when every message send so far has been confirmed by the peer end-point.

The initial state of the proxy is ReliableProxy.Connecting. In this state the proxy will repeatedly send Identify messages to ActorSelection(targetPath) in order to obtain a new ActorRef for the target. When an ActorIdentity for the target is received a new tunnel will be created, a ReliableProxy.TargetChanged message containing the target ActorRef will be sent to the proxy's transition subscribers and the proxy will transition into either the ReliableProxy.Idle or ReliableProxy.Active state, depending if there are any outstanding messages that need to be delivered. If maxConnectAttempts is defined this actor will stop itself after Identify is sent maxConnectAttempts times.

While in the Idle or Active states, if a communication failure causes the tunnel to terminate via Remote Deathwatch the proxy will transition into the ReliableProxy.Connecting state as described above. After reconnecting TargetChanged will be sent only if the target ActorRef has changed.

If this actor is stopped and it still has outstanding messages a ReliableProxy.ProxyTerminated message will be sent to the transition subscribers. It contains an Unsent object with the outstanding messages.

If an ReliableProxy.Unsent message is sent to this actor the messages contained within it will be relayed through the tunnel to the target.

Any other message type sent to this actor will be delivered via a remote-deployed child actor to the designated target.

==Failure Cases==

All failures of either the local or the remote end-point are escalated to the parent of this actor; there are no specific error cases which are predefined.

==Arguments== See the constructor below for the arguments for this actor. However, prefer using props(akka.actor.ActorPath, scala.concurrent.duration.FiniteDuration, scala.Option<scala.concurrent.duration.FiniteDuration>, scala.Option<java.lang.Object>) to this actor's constructor.

param: targetPath is the ActorPath to the actor to which all messages will be forwarded. targetPath can point to a local or remote actor, but the tunnel endpoint will be deployed remotely on the node where the target actor lives. param: retryAfter is the ACK timeout after which all outstanding messages will be resent. There is no limit on the queue size or the number of retries. param: reconnectAfter &nbsp;is an optional interval between connection attempts. It is also used as the interval between receiving a Terminated for the tunnel and attempting to reconnect to the target actor. The minimum recommended value for this is the value of the configuration setting akka.remote.retry-gate-closed-for. Use None to never reconnect after a disconnection. param: maxConnectAttempts &nbsp;is an optional maximum number of attempts to connect to the target actor. Use None for no limit. If reconnectAfter is None this value is ignored.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ReliableProxy.Active$
static class	ReliableProxy.Connecting$
static class	ReliableProxy.Idle$
static class	ReliableProxy.Message
static class	ReliableProxy.Message$
static class	ReliableProxy.ProxyTerminated ProxyTerminated is sent to transition subscribers during postStop.
static class	ReliableProxy.ProxyTerminated$
static class	ReliableProxy.Receiver
static interface	ReliableProxy.State
static class	ReliableProxy.TargetChanged TargetChanged is sent to transition subscribers when the initial connection is made the target and when the target ActorRef has changed (for example, the target system crashed and has been restarted).
static class	ReliableProxy.TargetChanged$
static class	ReliableProxy.Unsent
static class	ReliableProxy.Unsent$

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

FSM.$minus$greater$, FSM.CurrentState<S>, FSM.CurrentState$, FSM.Event<D>, FSM.Event$, FSM.Failure, FSM.Failure$, FSM.LogEntry<S,D>, FSM.LogEntry$, FSM.Normal$, FSM.NullFunction$, FSM.Reason, FSM.Shutdown$, FSM.SilentState<S,D>, FSM.State$, FSM.StateTimeout$, FSM.StopEvent<S,D>, FSM.StopEvent$, FSM.SubscribeTransitionCallBack, FSM.SubscribeTransitionCallBack$, FSM.TimeoutMarker, FSM.TimeoutMarker$, FSM.Timer, FSM.Timer$, FSM.TransformHelper, FSM.Transition<S>, FSM.Transition$, FSM.UnsubscribeTransitionCallBack, FSM.UnsubscribeTransitionCallBack$

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

Actor.emptyBehavior$, Actor.ignoringBehavior$

Constructor Summary

Constructors

Constructor and Description
ReliableProxy(ActorPath targetPath, scala.concurrent.duration.FiniteDuration retryAfter, scala.Option<scala.concurrent.duration.FiniteDuration> reconnectAfter, scala.Option<java.lang.Object> maxConnectAttempts)

Method Summary

Modifier and Type	Method and Description
static FSM.$minus$greater$	$minus$greater()
static ReliableProxy.Active$	active()
static java.lang.String	addSelf(java.lang.String template)
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 abstract static void	akka$actor$FSM$_setter_$$minus$greater_$eq(FSM.$minus$greater$ x$1)
protected abstract static void	akka$actor$FSM$_setter_$akka$actor$FSM$$handleEventDefault_$eq(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> x$1)
protected abstract static void	akka$actor$FSM$_setter_$akka$actor$FSM$$stateFunctions_$eq(scala.collection.mutable.Map<S,scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>>> x$1)
protected abstract static void	akka$actor$FSM$_setter_$akka$actor$FSM$$stateTimeouts_$eq(scala.collection.mutable.Map<S,scala.Option<scala.concurrent.duration.FiniteDuration>> x$1)
protected abstract static void	akka$actor$FSM$_setter_$akka$actor$FSM$$timerGen_$eq(scala.collection.Iterator<java.lang.Object> x$1)
protected abstract static void	akka$actor$FSM$_setter_$akka$actor$FSM$$timers_$eq(scala.collection.mutable.Map<java.lang.String,FSM.Timer> x$1)
protected abstract static void	akka$actor$FSM$_setter_$Event_$eq(FSM.Event$ x$1)
protected abstract static void	akka$actor$FSM$_setter_$StateTimeout_$eq(FSM.StateTimeout$ x$1)
protected abstract static void	akka$actor$FSM$_setter_$StopEvent_$eq(FSM.StopEvent$ x$1)
static void	akka$actor$FSM$$currentState_$eq(FSM.State<S,D> x$1)
static FSM.State<S,D>	akka$actor$FSM$$currentState()
static void	akka$actor$FSM$$generation_$eq(long x$1)
static long	akka$actor$FSM$$generation()
static void	akka$actor$FSM$$handleEvent_$eq(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> x$1)
static scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>>	akka$actor$FSM$$handleEvent()
static scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>>	akka$actor$FSM$$handleEventDefault()
static void	akka$actor$FSM$$nextState_$eq(FSM.State<S,D> x$1)
static FSM.State<S,D>	akka$actor$FSM$$nextState()
static scala.collection.mutable.Map<S,scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>>>	akka$actor$FSM$$stateFunctions()
static scala.collection.mutable.Map<S,scala.Option<scala.concurrent.duration.FiniteDuration>>	akka$actor$FSM$$stateTimeouts()
static void	akka$actor$FSM$$terminateEvent_$eq(scala.PartialFunction<FSM.StopEvent<S,D>,scala.runtime.BoxedUnit> x$1)
static scala.PartialFunction<FSM.StopEvent<S,D>,scala.runtime.BoxedUnit>	akka$actor$FSM$$terminateEvent()
static void	akka$actor$FSM$$timeoutFuture_$eq(scala.Option<Cancellable> x$1)
static scala.Option<Cancellable>	akka$actor$FSM$$timeoutFuture()
static scala.collection.Iterator<java.lang.Object>	akka$actor$FSM$$timerGen()
static scala.collection.mutable.Map<java.lang.String,FSM.Timer>	akka$actor$FSM$$timers()
static void	akka$actor$FSM$$transitionEvent_$eq(scala.collection.immutable.List<scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit>> x$1)
static scala.collection.immutable.List<scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit>>	akka$actor$FSM$$transitionEvent()
protected abstract static void	akka$actor$LoggingFSM$_setter_$akka$actor$LoggingFSM$$events_$eq(FSM.Event<D>[] x$1)
protected abstract static void	akka$actor$LoggingFSM$_setter_$akka$actor$LoggingFSM$$states_$eq(java.lang.Object[] x$1)
protected abstract static void	akka$actor$LoggingFSM$_setter_$debugEvent_$eq(boolean x$1)
static FSM.Event<D>[]	akka$actor$LoggingFSM$$events()
static void	akka$actor$LoggingFSM$$full_$eq(boolean x$1)
static boolean	akka$actor$LoggingFSM$$full()
static void	akka$actor$LoggingFSM$$pos_$eq(int x$1)
static int	akka$actor$LoggingFSM$$pos()
static java.lang.Object[]	akka$actor$LoggingFSM$$states()
protected abstract static void	akka$contrib$pattern$ReliableProxyDebugLogging$_setter_$debug_$eq(boolean x$1)
protected abstract static void	akka$routing$Listeners$_setter_$listeners_$eq(java.util.Set<ActorRef> x$1)
static void	applyState(FSM.State<S,D> nextState)
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)
int	attemptedReconnects()
static void	cancelTimer(java.lang.String name)
static int	compare(int a, int b) Wrap-around aware comparison of integers: differences limited to 2**31-1 in magnitude will work correctly.
ActorContext	context() Stores the context for this actor, including self, and sender.
void	createTunnel(ActorRef target)
int	currentSerial()
ActorRef	currentTarget()
boolean	debug()
boolean	debugEvent()
scala.concurrent.duration.FiniteDuration	defaultConnectInterval()
static boolean	enabled()
FSM.Event$	Event()
protected static scala.collection.IndexedSeq<FSM.LogEntry<S,D>>	getLog()
protected static void	gossip(java.lang.Object msg, ActorRef sender)
protected static ActorRef	gossip$default$2(java.lang.Object msg)
static ReliableProxy.Idle$	idle()
static void	initialize()
ReliableProxy.Connecting$	initialState()
static boolean	isStateTimerActive()
static boolean	isTimerActive(java.lang.String name)
int	lastAckSerial()
protected static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	listenerManagement()
protected java.util.Set<ActorRef>	listeners()
static LoggingAdapter	log()
static void	logDebug(java.lang.String template, java.lang.Object arg1)
static void	logDebug(java.lang.String template, java.lang.Object arg1, java.lang.Object arg2)
static int	logDepth()
void	logResend(int size)
protected static void	logTermination(FSM.Reason reason)
static void	makeTransition(FSM.State<S,D> nextState)
scala.concurrent.duration.FiniteDuration	nextBackoff() Returns the next retry interval duration.
int	nextSerial()
static D	nextStateData()
static void	onTermination(scala.PartialFunction<FSM.StopEvent<S,D>,scala.runtime.BoxedUnit> terminationHandler)
static void	onTransition(scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit> transitionHandler)
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 void	processEvent(FSM.Event<D> event, java.lang.Object source)
static Props	props(ActorPath targetPath, scala.concurrent.duration.FiniteDuration retryAfter) Props with no reconnections.
static Props	props(ActorPath targetPath, scala.concurrent.duration.FiniteDuration retryAfter, scala.concurrent.duration.FiniteDuration reconnectAfter) Props with no limit on reconnections.
static Props	props(ActorPath targetPath, scala.concurrent.duration.FiniteDuration retryAfter, scala.concurrent.duration.FiniteDuration reconnectAfter, int maxReconnects) Java API Props.
static Props	props(ActorPath targetPath, scala.concurrent.duration.FiniteDuration retryAfter, scala.Option<scala.concurrent.duration.FiniteDuration> reconnectAfter, scala.Option<java.lang.Object> maxReconnects) Scala API Props.
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	receive()
static Props	receiver(ActorRef target, int currentSerial)
static ReliableProxy.Connecting$	reconnecting()
java.lang.String	reconnectTimer()
scala.collection.immutable.Vector<ReliableProxy.Message>	resend(scala.collection.immutable.Vector<ReliableProxy.Message> q)
java.lang.String	resendTimer()
void	resetBackoff() Reset backoff interval.
long	retryGateClosedFor()
void	scheduleReconnectTick()
void	scheduleTick()
ActorRef	self() The 'self' field holds the ActorRef for this actor.
ReliableProxy.Message	send(java.lang.Object msg, ActorRef snd)
static ActorRef	sender()
static void	setStateTimeout(S state, scala.Option<scala.concurrent.duration.FiniteDuration> timeout)
static void	setTimer(java.lang.String name, java.lang.Object msg, scala.concurrent.duration.FiniteDuration timeout, boolean repeat)
static boolean	setTimer$default$4()
static void	startWith(S stateName, D stateData, scala.Option<scala.concurrent.duration.FiniteDuration> timeout)
static scala.Option<scala.concurrent.duration.FiniteDuration>	startWith$default$3()
static D	stateData()
static S	stateName()
FSM.StateTimeout$	StateTimeout() This case object is received in case of a state timeout.
static FSM.State<S,D>	stay()
static FSM.State<S,D>	stop()
static FSM.State<S,D>	stop(FSM.Reason reason)
static FSM.State<S,D>	stop(FSM.Reason reason, D stateData)
FSM.StopEvent$	StopEvent()
OneForOneStrategy	supervisorStrategy() User overridable definition the strategy to use for supervising child actors.
FSM.State<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>	terminated()
static scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit>	total2pf(scala.Function2<S,S,scala.runtime.BoxedUnit> transitionHandler)
static FSM.TransformHelper	transform(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> func)
ActorRef	tunnel()
static void	unhandled(java.lang.Object message)
scala.collection.immutable.Vector<ReliableProxy.Message>	updateSerial(scala.collection.immutable.Vector<ReliableProxy.Message> q)
static void	when(S stateName, scala.concurrent.duration.FiniteDuration stateTimeout, scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> stateFunction)
static scala.concurrent.duration.FiniteDuration	when$default$2()
static void	whenUnhandled(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> stateFunction)

Methods inherited from class java.lang.Object

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

Methods inherited from interface akka.actor.LoggingFSM

advance, getLog, logDepth, processEvent

Methods inherited from interface akka.actor.FSM

applyState, cancelTimer, handleTransition, initialize, isStateTimerActive, isTimerActive, logTermination, makeTransition, nextStateData, onTermination, onTransition, processMsg, register, setStateTimeout, setTimer, startWith, stateData, stateName, stay, stop, stop, stop, terminate, total2pf, transform, when, whenUnhandled

Methods inherited from interface akka.actor.Actor

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

Methods inherited from interface akka.routing.Listeners

gossip, listenerManagement

Methods inherited from interface akka.actor.ActorLogging

log

Methods inherited from interface akka.contrib.pattern.ReliableProxyDebugLogging

addSelf, enabled, logDebug, logDebug

Constructor Detail

ReliableProxy

public ReliableProxy(ActorPath targetPath,
                     scala.concurrent.duration.FiniteDuration retryAfter,
                     scala.Option<scala.concurrent.duration.FiniteDuration> reconnectAfter,
                     scala.Option<java.lang.Object> maxConnectAttempts)

Method Detail

props

public static Props props(ActorPath targetPath,
                          scala.concurrent.duration.FiniteDuration retryAfter,
                          scala.Option<scala.concurrent.duration.FiniteDuration> reconnectAfter,
                          scala.Option<java.lang.Object> maxReconnects)

Scala API Props. Arguments are detailed in the ReliableProxy constructor.

Parameters:

targetPath - (undocumented)

retryAfter - (undocumented)

reconnectAfter - (undocumented)

maxReconnects - (undocumented)

Returns:

(undocumented)

props

public static Props props(ActorPath targetPath,
                          scala.concurrent.duration.FiniteDuration retryAfter,
                          scala.concurrent.duration.FiniteDuration reconnectAfter,
                          int maxReconnects)

Java API Props. Arguments are detailed in the ReliableProxy constructor.

Parameters:

targetPath - (undocumented)

retryAfter - (undocumented)

reconnectAfter - (undocumented)

maxReconnects - (undocumented)

Returns:

(undocumented)

props

public static Props props(ActorPath targetPath,
                          scala.concurrent.duration.FiniteDuration retryAfter,
                          scala.concurrent.duration.FiniteDuration reconnectAfter)

Props with no limit on reconnections. Arguments are detailed in the ReliableProxy constructor.

Parameters:

targetPath - (undocumented)

retryAfter - (undocumented)

reconnectAfter - (undocumented)

Returns:

(undocumented)

props

public static Props props(ActorPath targetPath,
                          scala.concurrent.duration.FiniteDuration retryAfter)

Props with no reconnections. Arguments are detailed in the ReliableProxy constructor.

Parameters:

targetPath - (undocumented)

retryAfter - (undocumented)

Returns:

(undocumented)

compare

public static int compare(int a,
                          int b)

Wrap-around aware comparison of integers: differences limited to 2**31-1 in magnitude will work correctly.

Parameters:

a - (undocumented)

b - (undocumented)

Returns:

(undocumented)

receiver

public static Props receiver(ActorRef target,
                             int currentSerial)

idle

public static ReliableProxy.Idle$ idle()

active

public static ReliableProxy.Active$ active()

reconnecting

public static ReliableProxy.Connecting$ reconnecting()

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)

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)

listenerManagement

protected static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> listenerManagement()

gossip

protected static void gossip(java.lang.Object msg,
                             ActorRef sender)

gossip$default$2

protected static ActorRef gossip$default$2(java.lang.Object msg)

akka$routing$Listeners$_setter_$listeners_$eq

protected abstract static void akka$routing$Listeners$_setter_$listeners_$eq(java.util.Set<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()

$minus$greater

public static FSM.$minus$greater$ $minus$greater()

when

public static final void when(S stateName,
                              scala.concurrent.duration.FiniteDuration stateTimeout,
                              scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> stateFunction)

startWith

public static final void startWith(S stateName,
                                   D stateData,
                                   scala.Option<scala.concurrent.duration.FiniteDuration> timeout)

stay

public static final FSM.State<S,D> stay()

stop

public static final FSM.State<S,D> stop()

stop

public static final FSM.State<S,D> stop(FSM.Reason reason)

stop

public static final FSM.State<S,D> stop(FSM.Reason reason,
                                        D stateData)

transform

public static final FSM.TransformHelper transform(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> func)

setTimer

public static final void setTimer(java.lang.String name,
                                  java.lang.Object msg,
                                  scala.concurrent.duration.FiniteDuration timeout,
                                  boolean repeat)

cancelTimer

public static final void cancelTimer(java.lang.String name)

isTimerActive

public static final boolean isTimerActive(java.lang.String name)

setStateTimeout

public static final void setStateTimeout(S state,
                                         scala.Option<scala.concurrent.duration.FiniteDuration> timeout)

isStateTimerActive

public static final boolean isStateTimerActive()

onTransition

public static final void onTransition(scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit> transitionHandler)

total2pf

public static final scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit> total2pf(scala.Function2<S,S,scala.runtime.BoxedUnit> transitionHandler)

onTermination

public static final void onTermination(scala.PartialFunction<FSM.StopEvent<S,D>,scala.runtime.BoxedUnit> terminationHandler)

whenUnhandled

public static final void whenUnhandled(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> stateFunction)

initialize

public static final void initialize()

stateName

public static final S stateName()

stateData

public static final D stateData()

nextStateData

public static final D nextStateData()

akka$actor$FSM$$currentState

public static FSM.State<S,D> akka$actor$FSM$$currentState()

akka$actor$FSM$$currentState_$eq

public static void akka$actor$FSM$$currentState_$eq(FSM.State<S,D> x$1)

akka$actor$FSM$$timeoutFuture

public static scala.Option<Cancellable> akka$actor$FSM$$timeoutFuture()

akka$actor$FSM$$timeoutFuture_$eq

public static void akka$actor$FSM$$timeoutFuture_$eq(scala.Option<Cancellable> x$1)

akka$actor$FSM$$nextState

public static FSM.State<S,D> akka$actor$FSM$$nextState()

akka$actor$FSM$$nextState_$eq

public static void akka$actor$FSM$$nextState_$eq(FSM.State<S,D> x$1)

akka$actor$FSM$$generation

public static long akka$actor$FSM$$generation()

akka$actor$FSM$$generation_$eq

public static void akka$actor$FSM$$generation_$eq(long x$1)

akka$actor$FSM$$timers

public static scala.collection.mutable.Map<java.lang.String,FSM.Timer> akka$actor$FSM$$timers()

akka$actor$FSM$$timerGen

public static scala.collection.Iterator<java.lang.Object> akka$actor$FSM$$timerGen()

akka$actor$FSM$$stateFunctions

public static scala.collection.mutable.Map<S,scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>>> akka$actor$FSM$$stateFunctions()

akka$actor$FSM$$stateTimeouts

public static scala.collection.mutable.Map<S,scala.Option<scala.concurrent.duration.FiniteDuration>> akka$actor$FSM$$stateTimeouts()

akka$actor$FSM$$handleEventDefault

public static scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> akka$actor$FSM$$handleEventDefault()

akka$actor$FSM$$handleEvent

public static scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> akka$actor$FSM$$handleEvent()

akka$actor$FSM$$handleEvent_$eq

public static void akka$actor$FSM$$handleEvent_$eq(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> x$1)

akka$actor$FSM$$terminateEvent

public static scala.PartialFunction<FSM.StopEvent<S,D>,scala.runtime.BoxedUnit> akka$actor$FSM$$terminateEvent()

akka$actor$FSM$$terminateEvent_$eq

public static void akka$actor$FSM$$terminateEvent_$eq(scala.PartialFunction<FSM.StopEvent<S,D>,scala.runtime.BoxedUnit> x$1)

akka$actor$FSM$$transitionEvent

public static scala.collection.immutable.List<scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit>> akka$actor$FSM$$transitionEvent()

akka$actor$FSM$$transitionEvent_$eq

public static void akka$actor$FSM$$transitionEvent_$eq(scala.collection.immutable.List<scala.PartialFunction<scala.Tuple2<S,S>,scala.runtime.BoxedUnit>> x$1)

receive

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

applyState

public static void applyState(FSM.State<S,D> nextState)

makeTransition

public static void makeTransition(FSM.State<S,D> nextState)

logTermination

protected static void logTermination(FSM.Reason reason)

when$default$2

public static final scala.concurrent.duration.FiniteDuration when$default$2()

startWith$default$3

public static final scala.Option<scala.concurrent.duration.FiniteDuration> startWith$default$3()

setTimer$default$4

public static final boolean setTimer$default$4()

akka$actor$FSM$_setter_$Event_$eq

protected abstract static void akka$actor$FSM$_setter_$Event_$eq(FSM.Event$ x$1)

akka$actor$FSM$_setter_$StopEvent_$eq

protected abstract static void akka$actor$FSM$_setter_$StopEvent_$eq(FSM.StopEvent$ x$1)

akka$actor$FSM$_setter_$$minus$greater_$eq

protected abstract static void akka$actor$FSM$_setter_$$minus$greater_$eq(FSM.$minus$greater$ x$1)

akka$actor$FSM$_setter_$StateTimeout_$eq

protected abstract static void akka$actor$FSM$_setter_$StateTimeout_$eq(FSM.StateTimeout$ x$1)

akka$actor$FSM$_setter_$akka$actor$FSM$$timers_$eq

protected abstract static void akka$actor$FSM$_setter_$akka$actor$FSM$$timers_$eq(scala.collection.mutable.Map<java.lang.String,FSM.Timer> x$1)

akka$actor$FSM$_setter_$akka$actor$FSM$$timerGen_$eq

protected abstract static void akka$actor$FSM$_setter_$akka$actor$FSM$$timerGen_$eq(scala.collection.Iterator<java.lang.Object> x$1)

akka$actor$FSM$_setter_$akka$actor$FSM$$stateFunctions_$eq

protected abstract static void akka$actor$FSM$_setter_$akka$actor$FSM$$stateFunctions_$eq(scala.collection.mutable.Map<S,scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>>> x$1)

akka$actor$FSM$_setter_$akka$actor$FSM$$stateTimeouts_$eq

protected abstract static void akka$actor$FSM$_setter_$akka$actor$FSM$$stateTimeouts_$eq(scala.collection.mutable.Map<S,scala.Option<scala.concurrent.duration.FiniteDuration>> x$1)

akka$actor$FSM$_setter_$akka$actor$FSM$$handleEventDefault_$eq

protected abstract static void akka$actor$FSM$_setter_$akka$actor$FSM$$handleEventDefault_$eq(scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> x$1)

logDepth

public static int logDepth()

akka$actor$LoggingFSM$$events

public static FSM.Event<D>[] akka$actor$LoggingFSM$$events()

akka$actor$LoggingFSM$$states

public static java.lang.Object[] akka$actor$LoggingFSM$$states()

akka$actor$LoggingFSM$$pos

public static int akka$actor$LoggingFSM$$pos()

akka$actor$LoggingFSM$$pos_$eq

public static void akka$actor$LoggingFSM$$pos_$eq(int x$1)

akka$actor$LoggingFSM$$full

public static boolean akka$actor$LoggingFSM$$full()

akka$actor$LoggingFSM$$full_$eq

public static void akka$actor$LoggingFSM$$full_$eq(boolean x$1)

processEvent

public static void processEvent(FSM.Event<D> event,
                                java.lang.Object source)

getLog

protected static scala.collection.IndexedSeq<FSM.LogEntry<S,D>> getLog()

akka$actor$LoggingFSM$_setter_$debugEvent_$eq

protected abstract static void akka$actor$LoggingFSM$_setter_$debugEvent_$eq(boolean x$1)

akka$actor$LoggingFSM$_setter_$akka$actor$LoggingFSM$$events_$eq

protected abstract static void akka$actor$LoggingFSM$_setter_$akka$actor$LoggingFSM$$events_$eq(FSM.Event<D>[] x$1)

akka$actor$LoggingFSM$_setter_$akka$actor$LoggingFSM$$states_$eq

protected abstract static void akka$actor$LoggingFSM$_setter_$akka$actor$LoggingFSM$$states_$eq(java.lang.Object[] x$1)

enabled

public static boolean enabled()

addSelf

public static java.lang.String addSelf(java.lang.String template)

logDebug

public static void logDebug(java.lang.String template,
                            java.lang.Object arg1,
                            java.lang.Object arg2)

logDebug

public static void logDebug(java.lang.String template,
                            java.lang.Object arg1)

akka$contrib$pattern$ReliableProxyDebugLogging$_setter_$debug_$eq

protected abstract static void akka$contrib$pattern$ReliableProxyDebugLogging$_setter_$debug_$eq(boolean x$1)

debug

public boolean debug()

Specified by:

debug in interface ReliableProxyDebugLogging

debugEvent

public boolean debugEvent()

Specified by:

debugEvent in interface FSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>

Specified by:

debugEvent in interface LoggingFSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>

Event

public FSM.Event$ Event()

Specified by:

Event in interface FSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>

StopEvent

public FSM.StopEvent$ StopEvent()

Specified by:

StopEvent in interface FSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>

StateTimeout

public FSM.StateTimeout$ StateTimeout()

Description copied from interface: FSM

This case object is received in case of a state timeout.

Specified by:

StateTimeout in interface FSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>

Returns:

(undocumented)

listeners

protected java.util.Set<ActorRef> listeners()

Specified by:

listeners in interface Listeners

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)

tunnel

public ActorRef tunnel()

currentSerial

public int currentSerial()

lastAckSerial

public int lastAckSerial()

currentTarget

public ActorRef currentTarget()

attemptedReconnects

public int attemptedReconnects()

resendTimer

public java.lang.String resendTimer()

reconnectTimer

public java.lang.String reconnectTimer()

retryGateClosedFor

public long retryGateClosedFor()

defaultConnectInterval

public scala.concurrent.duration.FiniteDuration defaultConnectInterval()

initialState

public ReliableProxy.Connecting$ initialState()

createTunnel

public void createTunnel(ActorRef target)

supervisorStrategy

public OneForOneStrategy supervisorStrategy()

Description copied from interface: Actor

User overridable definition the strategy to use for supervising child actors.

Specified by:

supervisorStrategy in interface Actor

Returns:

(undocumented)

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

Specified by:

postStop in interface FSM<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>>

scheduleTick

public void scheduleTick()

nextSerial

public int nextSerial()

send

public ReliableProxy.Message send(java.lang.Object msg,
                                  ActorRef snd)

updateSerial

public scala.collection.immutable.Vector<ReliableProxy.Message> updateSerial(scala.collection.immutable.Vector<ReliableProxy.Message> q)

resend

public scala.collection.immutable.Vector<ReliableProxy.Message> resend(scala.collection.immutable.Vector<ReliableProxy.Message> q)

logResend

public void logResend(int size)

terminated

public FSM.State<ReliableProxy.State,scala.collection.immutable.Vector<ReliableProxy.Message>> terminated()

scheduleReconnectTick

public void scheduleReconnectTick()

resetBackoff

public void resetBackoff()

Reset backoff interval.

This and nextBackoff are meant to be implemented by subclasses.

nextBackoff

public scala.concurrent.duration.FiniteDuration nextBackoff()

Returns the next retry interval duration. By default each interval is the same, reconnectAfter.

Returns:

(undocumented)