akka.contrib.circuitbreaker

Class CircuitBreakerProxy

java.lang.Object

akka.contrib.circuitbreaker.CircuitBreakerProxy

All Implemented Interfaces:

Actor, ActorLogging, FSM<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>, Listeners

public final class CircuitBreakerProxy
extends java.lang.Object
implements Actor, ActorLogging, FSM<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	CircuitBreakerProxy.CircuitBreakerCommand
static interface	CircuitBreakerProxy.CircuitBreakerEvent
static class	CircuitBreakerProxy.CircuitBreakerInternalEvents$
static class	CircuitBreakerProxy.CircuitBreakerPropsBuilder
static class	CircuitBreakerProxy.CircuitBreakerPropsBuilder$
static interface	CircuitBreakerProxy.CircuitBreakerResponse
static interface	CircuitBreakerProxy.CircuitBreakerState
static class	CircuitBreakerProxy.CircuitBreakerStateData
static class	CircuitBreakerProxy.CircuitBreakerStateData$
static class	CircuitBreakerProxy.CircuitClosed
static class	CircuitBreakerProxy.CircuitClosed$
static class	CircuitBreakerProxy.CircuitHalfOpen
static class	CircuitBreakerProxy.CircuitHalfOpen$
static class	CircuitBreakerProxy.CircuitOpen
static class	CircuitBreakerProxy.CircuitOpen$
static class	CircuitBreakerProxy.CircuitOpenFailure
static class	CircuitBreakerProxy.CircuitOpenFailure$
static class	CircuitBreakerProxy.Closed$
static class	CircuitBreakerProxy.HalfOpen$
static class	CircuitBreakerProxy.Open$
static class	CircuitBreakerProxy.Passthrough
static class	CircuitBreakerProxy.Passthrough$
static class	CircuitBreakerProxy.TellOnly
static class	CircuitBreakerProxy.TellOnly$

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<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
CircuitBreakerProxy(ActorRef target, int maxFailures, Timeout callTimeout, Timeout resetTimeout, scala.Option<ActorRef> circuitEventListener, scala.Function1<java.lang.Object,java.lang.Object> failureDetector, scala.Function1<CircuitBreakerProxy.CircuitOpenFailure,java.lang.Object> failureMap)

Method Summary

Modifier and Type	Method and Description
static FSM.$minus$greater$	$minus$greater()
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$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)
scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>>	callSucceededHandling()
static void	cancelTimer(java.lang.String name)
scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>>	commonStateHandling()
ActorContext	context() Stores the context for this actor, including self, and sender.
static boolean	debugEvent()
FSM.Event$	Event()
void	forwardRequest(java.lang.Object message, ActorRef currentSender, CircuitBreakerProxy.CircuitBreakerStateData state, LoggingAdapter log)
protected static void	gossip(java.lang.Object msg, ActorRef sender)
protected static ActorRef	gossip$default$2(java.lang.Object msg)
static void	initialize()
static boolean	isStateTimerActive()
static boolean	isTimerActive(java.lang.String name)
protected static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	listenerManagement()
protected java.util.Set<ActorRef>	listeners()
static LoggingAdapter	log()
protected static void	logTermination(FSM.Reason reason)
static void	makeTransition(FSM.State<S,D> nextState)
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)
scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>>	passthroughHandling()
static void	postRestart(java.lang.Throwable reason)
static void	postStop()
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(ActorRef target, int maxFailures, Timeout callTimeout, Timeout resetTimeout, scala.Option<ActorRef> circuitEventListener, scala.Function1<java.lang.Object,java.lang.Object> failureDetector, scala.Function1<CircuitBreakerProxy.CircuitOpenFailure,java.lang.Object> failureMap) Creates an circuit breaker actor proxying a target actor intended for request-reply interactions.
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	receive()
ActorRef	self() The 'self' field holds the ActorRef for this actor.
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()
static SupervisorStrategy	supervisorStrategy()
scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>>	targetTerminationHandling()
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)
static void	unhandled(java.lang.Object message)
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.FSM

applyState, cancelTimer, debugEvent, handleTransition, initialize, isStateTimerActive, isTimerActive, logTermination, makeTransition, nextStateData, onTermination, onTransition, postStop, processEvent, processMsg, receive, 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, supervisorStrategy, unhandled

Methods inherited from interface akka.routing.Listeners

gossip, listenerManagement

Methods inherited from interface akka.actor.ActorLogging

log

Constructor Detail

CircuitBreakerProxy

public CircuitBreakerProxy(ActorRef target,
                           int maxFailures,
                           Timeout callTimeout,
                           Timeout resetTimeout,
                           scala.Option<ActorRef> circuitEventListener,
                           scala.Function1<java.lang.Object,java.lang.Object> failureDetector,
                           scala.Function1<CircuitBreakerProxy.CircuitOpenFailure,java.lang.Object> failureMap)

Method Detail

props

public static Props props(ActorRef target,
                          int maxFailures,
                          Timeout callTimeout,
                          Timeout resetTimeout,
                          scala.Option<ActorRef> circuitEventListener,
                          scala.Function1<java.lang.Object,java.lang.Object> failureDetector,
                          scala.Function1<CircuitBreakerProxy.CircuitOpenFailure,java.lang.Object> failureMap)

Creates an circuit breaker actor proxying a target actor intended for request-reply interactions. It is possible to send messages through this proxy without expecting a response wrapping them into a CircuitBreakerProxy.TellOnly or a CircuitBreakerProxy.Passthrough the difference between the two being that a message wrapped into a CircuitBreakerProxy.Passthrough is going to be forwarded even when the circuit is open (e.g. if you need to terminate the target and proxy actors sending a PoisonPill message)

The circuit breaker implements the same state machine documented in CircuitBreaker

Parameters:

target - the actor to proxy

maxFailures - maximum number of failures before opening the circuit

callTimeout - timeout before considering the ongoing call a failure

resetTimeout - time after which the channel will be closed after entering the open state

circuitEventListener - an actor that will receive a series of messages of type CircuitBreakerProxy.CircuitBreakerEvent

failureDetector - function to detect if the a message received from the target actor as response from a request represent a failure

failureMap - function to map a failure into a response message. The failing response message is wrapped into a CircuitBreakerProxy.CircuitOpenFailure object

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()

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)

$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()

debugEvent

public static boolean debugEvent()

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()

processEvent

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

applyState

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

makeTransition

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

postStop

public static void postStop()

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)

Event

public FSM.Event$ Event()

Specified by:

Event in interface FSM<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>

StopEvent

public FSM.StopEvent$ StopEvent()

Specified by:

StopEvent in interface FSM<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>

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<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>

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)

callSucceededHandling

public scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>> callSucceededHandling()

passthroughHandling

public scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>> passthroughHandling()

targetTerminationHandling

public scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>> targetTerminationHandling()

commonStateHandling

public scala.PartialFunction<FSM.Event<CircuitBreakerProxy.CircuitBreakerStateData>,FSM.State<CircuitBreakerProxy.CircuitBreakerState,CircuitBreakerProxy.CircuitBreakerStateData>> commonStateHandling()

forwardRequest

public void forwardRequest(java.lang.Object message,
                           ActorRef currentSender,
                           CircuitBreakerProxy.CircuitBreakerStateData state,
                           LoggingAdapter log)