2015 live coding updates

Author: acruise

sbt-skeleton/build.sbt

@@ -4,5 +4,8 @@ libraryDependencies := Seq(
   "com.typesafe.akka" %% "akka-actor" % "2.3.11",
   "io.spray" %% "spray-can" % "1.3.3",
   "io.spray" %% "spray-routing" % "1.3.3",
-  "io.spray" %% "spray-json" % "1.3.2"
+  "io.spray" %% "spray-json" % "1.3.2",
+  "com.typesafe.slick" %% "slick" % "3.0.0",
+  "org.slf4j" % "slf4j-nop" % "1.6.4",
+  "com.h2database" % "h2" % "1.4.187"
 )

sbt-skeleton/src/main/resources/application.conf

@@ -0,0 +1,6 @@
+polyglot2015 = {
+  url = "jdbc:h2:mem:polyglot2015"
+  driver = org.h2.Driver
+  connectionPool = disabled
+  keepAliveConnection = true
+}

sbt-skeleton/src/main/scala/com/cluonflux/polyglot/NumberGuessWeb.scala

@@ -9,7 +9,10 @@ import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.Future
 import scala.concurrent.Await
 
-object NumberGuessWeb extends App with SimpleRoutingApp with spray.httpx.SprayJsonSupport {
+object NumberGuessWeb extends App
+  with SimpleRoutingApp
+  with spray.httpx.SprayJsonSupport
+{
   implicit val system = ActorSystem("my-system")
 
   val game = system.actorOf(Props(new NumberGameActor))
@@ -36,7 +39,7 @@ object NumberGuessWeb extends App with SimpleRoutingApp with spray.httpx.SprayJs
   implicit val taggedHighF = new JsonWriter[High] {
     def write(high: High): JsValue = {
       highF.write(high) match {
-	case JsObject(fields) => 
+	      case JsObject(fields) =>
           JsObject(fields + ("status" -> JsString("High")))
       }
     }
@@ -62,33 +65,33 @@ object NumberGuessWeb extends App with SimpleRoutingApp with spray.httpx.SprayJs
   startServer(interface = "localhost", port = 8080) {
     path("restgame") {
       get {
-	complete(
-	  game.ask(QueryGuesses).mapTo[RemainingGuesses]
-	)	
+	      complete(
+	        game.ask(QueryGuesses).mapTo[RemainingGuesses]
+	      )
       } ~ post {
-	entity(as[Guess]) { guess =>  
+	      entity(as[Guess]) { guess =>
           val jsonFuture = game.ask(guess).map {
-	    case w: Won.type => JsObject(Map("status" -> JsString("Won")))
-	    case l: Lost.type => JsObject(Map("status" -> JsString("Lost")))
+            case w: Won.type => JsObject(Map("status" -> JsString("Won")))
+            case l: Lost.type => JsObject(Map("status" -> JsString("Lost")))
 
-	    case h: High => h.toJson
+            case h: High => h.toJson
             case l: Low => l.toJson
-  	  }
+    	  }
 
-  	  complete(jsonFuture.map(_.prettyPrint))
-	}
-      }
-    } ~ path("game") {
-      get {
-        complete {
+    	  complete(jsonFuture.map(_.prettyPrint))
+	    }
+    }
+  } ~ path("game") {
+    get {
+      complete {
           <xml:group>
             <h1>Welcome to the Number Game</h1>
 	    {form("/game")}
           </xml:group>
         }
       } ~ post {
 	formFields('guessed.as[Int]) { (guessed) =>
-          val htmlFuture = game.ask(Guess(guessed)) map {
+    val htmlFuture = game.ask(Guess(guessed)) map {
 	    case Won => <h1>You won!</h1>
 	    case Lost => <h1>You lost! :(</h1>
 
@@ -104,6 +107,7 @@ object NumberGuessWeb extends App with SimpleRoutingApp with spray.httpx.SprayJs
                  {form("/game")}
               </xml:group>
 	  }
+
 	  complete(htmlFuture)
 	}
       }

sbt-skeleton/src/main/scala/com/cluonflux/polyglot/polyglot2015/DB.scala

@@ -0,0 +1,86 @@
+package com.cluonflux.polyglot.polyglot2015
+
+import java.util.UUID
+
+import slick.ast.ScalaBaseType
+import slick.driver.H2Driver.api._
+import slick.lifted.{ProvenShape, ForeignKeyQuery}
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.util.{Success, Failure}
+
+case class Guid[T](raw: UUID) extends AnyVal
+
+object Guid {
+  def apply[T](): Guid[T] = Guid[T](UUID.randomUUID())
+  def apply[T](s: String): Guid[T] = Guid[T](UUID.fromString(s))
+}
+
+// case class Cage(guid: Guid[Cage], name: String)
+
+trait AnimalsSchema {
+  implicit def guidMapper[T] = MappedColumnType.base[Guid[T], String](_.raw.toString, Guid[T](_))
+
+  class Cage(tag: Tag) extends Table[(Guid[Cage], String)](tag, "cages") {
+    def guid = column[Guid[Cage]]("guid", O.PrimaryKey)
+    def name = column[String]("name")
+
+    def * = (guid, name)
+  }
+
+  val cageQuery = TableQuery[Cage]
+
+  class Animal(tag: Tag) extends Table[(Guid[Animal], Guid[Cage], String)](tag, "animals") {
+    def guid     = column[Guid[Animal]]("guid", O.PrimaryKey)
+    def cageGuid = column[Guid[Cage]]("cage_guid")
+    def name     = column[String]("name")
+
+    def fk_cageGuid = foreignKey("fk_animal_cage", cageGuid, cageQuery)(_.guid)
+
+    def * = (guid, cageGuid, name)
+  }
+
+  val animalQuery = TableQuery[Animal]
+}
+
+object DB extends AnimalsSchema {
+  val db = Database.forConfig("polyglot2015")
+
+  val cageGuid = Guid[Cage]()
+
+  val setup = DBIO.seq(
+    (cageQuery.schema ++ animalQuery.schema).create,
+
+    cageQuery += (cageGuid, "The big one"),
+    animalQuery ++= Seq(
+      (Guid[Animal](), cageGuid, "Fluffy the cat"),
+      (Guid[Animal](), cageGuid, "Dumbo the elephant")
+    )
+  )
+
+  def main(args: Array[String]): Unit = {
+    try {
+      val setupFuture = db.run(setup)
+      setupFuture.onComplete {
+        case Success(()) =>
+          // It's a database!
+          val shorties = for {
+            animal <- animalQuery
+            if animal.name === args(0)
+          } yield animal.guid
+
+          val xx = db.run(shorties.result)
+          xx.foreach { guids =>
+            guids.foreach { guid =>
+              println(guid)
+            }
+          }
+
+        case Failure(t) =>
+          throw t
+      }
+      Thread.sleep(10000)
+    } finally {
+      db.close()
+    }
+  }
+}

sbt-skeleton/src/main/scala/com/cluonflux/polyglot/polyglot2015/Unreliable.scala

@@ -0,0 +1,62 @@
+package com.cluonflux.polyglot.polyglot2015
+
+import akka.actor.SupervisorStrategy.Escalate
+import akka.actor._
+
+import scala.concurrent.duration._
+
+object Unreliable {
+  def main(args: Array[String]): Unit = {
+    val sys = ActorSystem("unreliable")
+
+    sys.actorOf(Props(new RootActor()))
+  }
+}
+
+final class RootActor extends Actor with ActorLogging {
+  override def supervisorStrategy: SupervisorStrategy = OneForOneStrategy(10, 10.minute) {
+    case e: RuntimeException =>
+      Escalate
+  }
+
+  override def preStart(): Unit = {
+    self ! 'init
+  }
+
+  var child: Option[ActorRef] = None
+
+  override def receive: Receive = {
+    case 'init =>
+      log.info("Parent is initializing!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+      val ref = context.actorOf(Props(new ChildActor()))
+
+      child = Some(ref)
+      context.watch(ref)
+
+    case 'panic =>
+      child.foreach(context.stop)
+
+    case Terminated(victim) =>
+      log.info("O NOESS!!! {} died!", victim)
+  }
+}
+
+final class ChildActor extends Actor with ActorLogging {
+  private val rnd = new scala.util.Random()
+
+  override def preStart(): Unit = {
+    self ! 'init
+  }
+
+  override def receive: Actor.Receive = {
+    case 'init =>
+      import scala.concurrent.ExecutionContext.Implicits.global
+
+      context.system.scheduler.schedule(1.second, 1.second, self, 'tick)
+
+    case 'tick =>
+      log.info("Tick!")
+
+      if (rnd.nextInt() % 10 == 0) sys.error("Whoops!")
+  }
+}