ryantanner

akka.actor.deployment {
  /analytics/leader {
    router = round-robin
    nr-of-instances = 100
    cluster {
      enabled = on
      max-nr-of-instances-per-node = 3
      allow-local-routees = off
      use-role = analytics
    }

ryantanner

case class User(id: Long, name: String)
class Work { /* ... */ }
class Result { /* --- */ }

case class WorkToBeDone(user: User, work: Work)
case class WorkIsDone(user: User, result: Result)

class Worker extends Actor { /* ... */ }

class BadWorkerCoordinator extends Actor {

ryantanner

/** Reads queue of new users to index */
class NewUserQueue extends Actor with ActorLogging { ... }

// Define our messages for the NewUserQueue
object NewUserQueue {
  case class Listen(ref: ActorRef)
  case class StopListen(ref: ActorRef)
  case class NewUsers(users: Seq[User])
}

ryantanner

object UserPipeline {

  case class Listen(ref: ActorRef)
  case class Start(user: User)
  case class Success(user: User)

}

class UserPipeline(
  val source: ActorRef // This is an actor that produces a stream of users to be processed

ryantanner

class MyCounter extends Actor {
  
  var count = 0
  
  def receive = {
    case Add => count + 1
    case GetCount = sender tell count
  }
  
}

ryantanner

val some5: Option[Int] = Some(5)
val missingInt: Option[Int] = None

val i: Int = 42 // Good
val i: Int = "Hello" // Compiler error

String st = "Hello" // Compiles
String st = null // Danger! Also compiles!

def findUserById(id: Int): Option[User] = {

ryantanner

akka {

  log-config-on-start = on

  actor {
    provider = "akka.cluster.ClusterActorRefProvider"
  }
  remote {
    log-remote-lifecycle-events = off
    netty.tcp {

ryantanner

// Play controller  
  
  def source(flightIdent: String) = Action {
    Async {
      for {      
        flight          <- Flight.findByIdent(flightIdent)
        source          <- (eventSource ? Track(flight))
      } yield source match { case Connected(stream) =>

        Ok.feed((stream &> EventSource[JsValue]()(

ryantanner

import sbt._
import sbt.Keys._
import PlayProject._
import akka.sbt.AkkaKernelPlugin
import akka.sbt.AkkaKernelPlugin.{ Dist, outputDirectory, distJvmOptions, configSourceDirs, distMainClass }
import com.typesafe.sbt.SbtMultiJvm
import com.typesafe.sbt.SbtMultiJvm.MultiJvmKeys._
import sbtassembly.Plugin._
import AssemblyKeys._
import twirl.sbt.TwirlPlugin._

ryantanner

// pass in the role name of the service being tested
object MultiSpecConfig extends MultiNodeConfig {
  // register the named roles (nodes) of the test
  val supervisor = role("supervisor")
  val service1 = role("service1")
  val service2 = role("service2")

  val nodeConfig: Config = ConfigFactory.parseString(s"""
    akka.actor.provider = "akka.cluster.ClusterActorRefProvider"
    akka.remote.log-remote-lifecycle-events = off