ActorHierarchyExperiments.scala

// actor started
// First: Actor[akka://testSystem/user/first-actor#-477064136]
// >>> Press ENTER to exit <<<
// Second: Actor[akka://testSystem/user/first-actor/second-actor#1443434381]
// sub-actor started
// sub-actor stopped
// actor stopped

package com.lightbend.akka.sample

import akka.actor.{ Actor, Props, ActorSystem }
import scala.io.StdIn

object Printer {
  case object PrintIt
  case object Stop
}

// Supervisor
class PrintMyActorRefActor extends Actor {
  import Printer._

  override def preStart(): Unit = println("actor started")
  override def postStop(): Unit = println("actor stopped")

  override def receive: Receive = {
    case PrintIt =>
      val secondRef = context.actorOf(Props[PrintMySubActorRefActor], "second-actor")
      println(s"Second: $secondRef")
    case Stop => context.stop(self)
  }
}

// Supervised
class PrintMySubActorRefActor extends Actor {
  override def preStart(): Unit = println("sub-actor started")
  override def postStop(): Unit = println("sub-actor stopped")

  override def receive: Receive = Actor.emptyBehavior
}

object ActorHierarchyExperiments extends App {
  import Printer._

  val system: ActorSystem = ActorSystem("testSystem");

  val firstRef = system.actorOf(Props[PrintMyActorRefActor], "first-actor")
  println(s"First: $firstRef")
  firstRef ! PrintIt
  
  // Supervisor will stop those it supervises first
  firstRef ! Stop

  println(">>> Press ENTER to exit <<<")
  try StdIn.readLine()
  finally system.terminate()
}

LensExperiments.scala

import monocle.macros.syntax.lens._
import io.circe.generic.auto._, io.circe.syntax._

case class Street(number: Int, name: String)
case class Address(city: String, street: Street, zip: String)
case class Company(name: String, address: Address)
case class Employee(name: String, company: Company)

var employee = Employee("john", Company("awesome inc", Address("london", Street(23, "high street"), "abc-1234")))

employee = employee
  .lens(_.name).set("Joshua K. Farrar")
  .lens(_.company.name).set("Sent1nel Labs")
  .lens(_.company.address.street.name).set("1600 Pennsylvania Ave SE")
  .lens(_.company.address.city).set("Washington DC")
  .lens(_.company.address.zip).set("20500")

println(s"${employee.lens(_.name).get}")
println(s"${employee.lens(_.company.name).get}")
println(s"${employee.lens(_.company.address.street.name).get}")
println(s"${employee.lens(_.company.address.city).get}. ${employee.lens(_.company.address.zip).get}.")

employee.asJson.noSpaces

PersistenceExperiments.scala

package com.lightbend.akka.sample

import akka.actor.{ Actor, Props, ActorSystem }
import akka.persistence.{ PersistentActor, Recovery, SnapshotSelectionCriteria }
import scala.io.StdIn

object UserHelper {
  case object CreateUser
}

case class Cmd(data: String)
case class Evt(data: String)

case class ExampleState(events: List[String] = Nil) {
  def updated(evt: Evt): ExampleState = copy(evt.data :: events)
  def size: Int = events.length
  override def toString: String = events.reverse.toString
}

class UserSupervisor extends Actor {
  import UserHelper._

  override def preStart(): Unit = println("user supervisor started")
  override def postStop(): Unit = println("user supervisor stopped")

  override def receive: Receive = {
    case CreateUser =>
      val userRef = context.actorOf(Props[User], "user")
      userRef ! Cmd("hello world") // this works!
      println(s"Supervisor created user: $userRef")
  }
}

class User extends PersistentActor {
  override def persistenceId = "sample-id-1"

  override def preStart(): Unit = println(s"user actor started: $persistenceId")
  override def postStop(): Unit = println(s"user actor stopped: $persistenceId")

  var state = ExampleState()

  def updateState(event: Evt): Unit = {
    state = state.updated(event)
    println(state)
  }

  override def recovery =
    Recovery(fromSnapshot = SnapshotSelectionCriteria.None)

  val receiveRecover: Receive = {
    case evt: Evt => updateState(evt)
  }

  override def receiveCommand: Receive = {
    case Cmd(data) =>
      persist(Evt(s"${data}")) { event =>
        updateState(event)
        context.system.eventStream.publish(event)
      }
  }
}

object ActorPersistenceExperiments extends App {
  import UserHelper._

  val system: ActorSystem = ActorSystem("testSystem");

  val userSupervisorRef = system.actorOf(Props[UserSupervisor], "user-supervisor")
  println(s"First: $userSupervisorRef")

  val user = userSupervisorRef ! CreateUser

  println(">>> Press ENTER to exit <<<")
  try StdIn.readLine()
  finally system.terminate()
}