AKKA -> Hot Swapping an Actor Behavior

cache.scala

class CacheSupervisorActor extends Actor with ActorLogging {

  import CacheSupervisorActor._

  val cache = context.actorOf(Props[CacheHotSwapActor])

  override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
    case e: ActorInitializationException => cache ! Memcached; Restart // When redis fails to connect, try memcached
    case e: IllegalStateException => Stop  // When memcached fails to connect
  }

  def receive = {
    case message => cache forward message
  }

  override def preStart() = cache ! Redis

}

sealed class CacheHotSwapActor extends Actor with ActorLogging {

  lazy val redisActor = context.actorOf(Props[RedisActor], "redis")
  lazy val memcachedActor = context.actorOf(Props[MemcachedActor], "memcached")

  import CacheSupervisorActor._
  import context._

  override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
    case _ => Escalate
  }

  def memcachedReceiveLoop: Receive = {
    case message@Set(_, _, _) => memcachedActor forward message
    case message@Get(_) => memcachedActor forward message
    case message@Del(_) => memcachedActor forward message
  }

  def redisReceiveLoop: Receive = {
    case message@Set(_, _, _) => redisActor forward message
    case message@Get(_) => redisActor forward message
    case message@Del(_) => redisActor forward message
  }

  def receive = {
    case Memcached => become(memcachedReceiveLoop)
    case Redis => become(redisReceiveLoop)
  }

}