FSM

The FSM Trait and Object

The FSM trait may only be mixed into an Actor. Instead of extending Actor, the self type approach was chosen in order to make it obvious that an actor is actually created:

class Buncher extends Actor with FSM[State, Data] {

  // fsm body ...

  initialize
}

The FSM trait takes two type parameters:

1. the supertype of all state names, usually a sealed trait with case objects extending it,
2. the type of the state data which are tracked by the FSM module itself.

Defining States

A state is defined by one or more invocations of the method

when(<name>[, stateTimeout = <timeout>])(stateFunction).

The given name must be an object which is type-compatible with the first type parameter given to the FSM trait. This object is used as a hash key, so you must ensure that it properly implements equals and hashCode; in particular it must not be mutable. The easiest fit for these requirements are case objects.

If the stateTimeout parameter is given, then all transitions into this state, including staying, receive this timeout by default. Initiating the transition with an explicit timeout may be used to override this default, see Initiating Transitions for more information. The state timeout of any state may be changed during action processing with setStateTimeout(state, duration). This enables runtime configuration e.g. via external message.

The stateFunction argument is a PartialFunction[Event, State], which is conveniently given using the partial function literal syntax as demonstrated below:

when(Idle) {
  case Event(SetTarget(ref), Uninitialized) ⇒
    stay using Todo(ref, Vector.empty)
}

when(Active, stateTimeout = 1 second) {
  case Event(Flush | StateTimeout, t: Todo) ⇒
    goto(Idle) using t.copy(queue = Vector.empty)
}

The Event(msg: Any, data: D) case class is parameterized with the data type held by the FSM for convenient pattern matching.

It is recommended practice to declare the states as objects extending a sealed trait and then verify that there is a when clause for each of the states. If you want to leave the handling of a state “unhandled” (more below), it still needs to be declared like this:

when(SomeState)(FSM.NullFunction)

Defining the Initial State

Each FSM needs a starting point, which is declared using

startWith(state, data[, timeout])

The optionally given timeout argument overrides any specification given for the desired initial state. If you want to cancel a default timeout, use Duration.Inf.

Unhandled Events

If a state doesn't handle a received event a warning is logged. If you want to do something else in this case you can specify that with whenUnhandled(stateFunction):

whenUnhandled {
  case Event(x: X, data) ⇒
    log.info("Received unhandled event: " + x)
    stay
  case Event(msg, _) ⇒
    log.warning("Received unknown event: " + msg)
    goto(Error)
}

Within this handler the state of the FSM may be queried using the stateName method.

IMPORTANT: This handler is not stacked, meaning that each invocation of whenUnhandled replaces the previously installed handler.

Initiating Transitions

The result of any stateFunction must be a definition of the next state unless terminating the FSM, which is described in Termination from Inside. The state definition can either be the current state, as described by the stay directive, or it is a different state as given by goto(state). The resulting object allows further qualification by way of the modifiers described in the following:

• forMax(duration)

  This modifier sets a state timeout on the next state. This means that a timer is started which upon expiry sends a StateTimeout message to the FSM. This timer is canceled upon reception of any other message in the meantime; you can rely on the fact that the StateTimeout message will not be processed after an intervening message.

  This modifier can also be used to override any default timeout which is specified for the target state. If you want to cancel the default timeout, use Duration.Inf.

• using(data)

  This modifier replaces the old state data with the new data given. If you follow the advice above, this is the only place where internal state data are ever modified.

• replying(msg)

  This modifier sends a reply to the currently processed message and otherwise does not modify the state transition.

All modifier can be chained to achieve a nice and concise description:

when(SomeState) {
  case Event(msg, _) ⇒
    goto(Processing) using (newData) forMax (5 seconds) replying (WillDo)
}

The parentheses are not actually needed in all cases, but they visually distinguish between modifiers and their arguments and therefore make the code even more pleasant to read for foreigners.

Monitoring Transitions

Transitions occur "between states" conceptually, which means after any actions you have put into the event handling block; this is obvious since the next state is only defined by the value returned by the event handling logic. You do not need to worry about the exact order with respect to setting the internal state variable, as everything within the FSM actor is running single-threaded anyway.

onTransition {
  case Idle -> Active ⇒ setTimer("timeout", Tick, 1 second, true)
  case Active -> _    ⇒ cancelTimer("timeout")
  case x -> Idle      ⇒ log.info("entering Idle from " + x)
}

onTransition(handler _)

def handler(from: StateType, to: StateType) {
  // handle it here ...
}

Transforming State

The partial functions supplied as argument to the when() blocks can be transformed using Scala’s full supplement of functional programming tools. In order to retain type inference, there is a helper function which may be used in case some common handling logic shall be applied to different clauses:

when(SomeState)(transform {
  case Event(bytes: Array[Byte], read) ⇒ stay using (read + bytes.length)
  case Event(bytes: List[Byte], read)  ⇒ stay using (read + bytes.size)
} using {
  case s @ FSM.State(state, read, timeout, stopReason, replies) if read > 1000 ⇒
    goto(Processing)
})

It goes without saying that the arguments to this method may also be stored, to be used several times, e.g. when applying the same transformation to several when() blocks:

val processingTrigger: PartialFunction[State, State] = {
  case s @ FSM.State(state, read, timeout, stopReason, replies) if read > 1000 ⇒
    goto(Processing)
}

when(SomeState)(transform {
  case Event(bytes: Array[Byte], read) ⇒ stay using (read + bytes.length)
  case Event(bytes: List[Byte], read)  ⇒ stay using (read + bytes.size)
} using processingTrigger)

Timers

Besides state timeouts, FSM manages timers identified by String names. You may set a timer using

setTimer(name, msg, interval, repeat)

where msg is the message object which will be sent after the duration interval has elapsed. If repeat is true, then the timer is scheduled at fixed rate given by the interval parameter. Timers may be canceled using

cancelTimer(name)

which is guaranteed to work immediately, meaning that the scheduled message will not be processed after this call even if the timer already fired and queued it. The status of any timer may be inquired with

timerActive_?(name)

These named timers complement state timeouts because they are not affected by intervening reception of other messages.

Termination from Inside

The FSM is stopped by specifying the result state as

stop([reason[, data]])

The reason must be one of Normal (which is the default), Shutdown or Failure(reason), and the second argument may be given to change the state data which is available during termination handling.

when(Error) {
  case Event("stop", _) ⇒
    // do cleanup ...
    stop()
}

You can use onTermination(handler) to specify custom code that is executed when the FSM is stopped. The handler is a partial function which takes a StopEvent(reason, stateName, stateData) as argument:

onTermination {
  case StopEvent(FSM.Normal, state, data)         ⇒ // ...
  case StopEvent(FSM.Shutdown, state, data)       ⇒ // ...
  case StopEvent(FSM.Failure(cause), state, data) ⇒ // ...
}

As for the whenUnhandled case, this handler is not stacked, so each invocation of onTermination replaces the previously installed handler.

Termination from Outside

When an ActorRef associated to a FSM is stopped using the stop method, its postStop hook will be executed. The default implementation by the FSM trait is to execute the onTermination handler if that is prepared to handle a StopEvent(Shutdown, ...).

Event Tracing

The setting akka.actor.debug.fsm in Configuration enables logging of an event trace by LoggingFSM instances:

import akka.actor.LoggingFSM
class MyFSM extends Actor with LoggingFSM[StateType, Data] {
  // body elided ...
}

This FSM will log at DEBUG level:

• all processed events, including StateTimeout and scheduled timer messages
• every setting and cancellation of named timers
• all state transitions

Life cycle changes and special messages can be logged as described for Actors.

Rolling Event Log

The LoggingFSM trait adds one more feature to the FSM: a rolling event log which may be used during debugging (for tracing how the FSM entered a certain failure state) or for other creative uses:

import akka.actor.LoggingFSM
class MyFSM extends Actor with LoggingFSM[StateType, Data] {
  override def logDepth = 12
  onTermination {
    case StopEvent(FSM.Failure(_), state, data) ⇒
      val lastEvents = getLog.mkString("\n\t")
      log.warning("Failure in state " + state + " with data " + data + "\n" +
        "Events leading up to this point:\n\t" + lastEvents)
  }
  // ...
}

The logDepth defaults to zero, which turns off the event log.

The contents of the event log are available using method getLog, which returns an IndexedSeq[LogEntry] where the oldest entry is at index zero.