In the beginning there was darkness

This is a production-grade play application that does absolutely nothing
of note.

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄░░░░░░░░░
░░░░░░░░▄▀░░░░░░░░░░░░▄░░░░░░░▀▄░░░░░░░
░░░░░░░░█░░▄░░░░▄░░░░░░░░░░░░░░█░░░░░░░
░░░░░░░░█░░░░░░░░░░░░▄█▄▄░░▄░░░█░▄▄▄░░░
░▄▄▄▄▄░░█░░░░░░▀░░░░▀█░░▀▄░░░░░█▀▀░██░░
░██▄▀██▄█░░░▄░░░░░░░██░░░░▀▀▀▀▀░░░░██░░
░░▀██▄▀██░░░░░░░░▀░██▀░░░░░░░░░░░░░▀██░
░░░░▀████░▀░░░░▄░░░██░░░▄█░░░░▄░▄█░░██░
░░░░░░░▀█░░░░▄░░░░░██░░░░▄░░░▄░░▄░░░██░
░░░░░░░▄█▄░░░░░░░░░░░▀▄░░▀▀▀▀▀▀▀▀░░▄▀░░
░░░░░░█▀▀█████████▀▀▀▀████████████▀░░░░
░░░░░░████▀░░███▀░░░░░░▀███░░▀██▀░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

Author: mriehl

.gitignore

@@ -0,0 +1,12 @@
+/logs/
+/modules
+/project/project
+/project/target
+/target
+server.pid
+*.iml
+*.eml
+.cache
+.ensime*
+/project/local.sbt
+.DS_Store

README.org

@@ -0,0 +1,16 @@
+* Carjump challenge
+
+** Dependencies
+   You will need to install [[http://www.scala-sbt.org/][SBT]] which requires a JDK installation.
+
+** Run the tests:
+#+BEGIN_SRC
+sbt test
+#+END_SRC
+
+** Run the application:
+#+BEGIN_SRC
+sbt run
+#+END_SRC
+
+** Design decisions

app/clients/ClientsModule.scala

@@ -0,0 +1,14 @@
+package clients
+
+import scala.concurrent.ExecutionContext
+
+import play.api.Configuration
+import play.api.libs.ws.WSClient
+
+trait ClientsModule {
+  def wsClient: WSClient
+
+  implicit def configuration: Configuration
+
+  implicit val executionContext: ExecutionContext
+}

app/controllers/ControllerModule.scala

@@ -0,0 +1,15 @@
+package controllers
+
+import scala.concurrent.ExecutionContext
+
+import com.softwaremill.macwire._
+import play.api.Configuration
+
+trait ControllerModule {
+
+  implicit def configuration: Configuration
+
+  implicit val executionContext: ExecutionContext
+
+  lazy val statusController: StatusController = wire[StatusController]
+}

app/controllers/StatusController.scala

@@ -0,0 +1,13 @@
+package controllers
+
+import scala.concurrent.{ Future, ExecutionContext }
+
+import play.api.mvc.{ AnyContent, Action, Controller }
+import util.SLF4JLogging
+
+class StatusController()(implicit ec: ExecutionContext) extends Controller with SLF4JLogging {
+  def status: Action[AnyContent] = Action.async {
+    request ⇒
+      Future.successful(Ok("OK"))
+  }
+}

app/jobs/JobsModule.scala

@@ -0,0 +1,23 @@
+package jobs
+
+import scala.concurrent.ExecutionContext
+
+import akka.actor.{ ActorSystem, Props }
+import akka.stream.Materializer
+import com.softwaremill.macwire._
+import play.api.Configuration
+
+trait JobsModule {
+
+  implicit val actorSystem: ActorSystem
+
+  implicit val executionContext: ExecutionContext
+
+  implicit def configuration: Configuration
+
+  implicit def materializer: Materializer
+
+  lazy val jobsSupervisorActor = {
+    actorSystem.actorOf(Props(wire[JobsSupervisorActor]))
+  }
+}

app/jobs/JobsSupervisorActor.scala

@@ -0,0 +1,26 @@
+package jobs
+
+import akka.actor._
+import jobs.JobsSupervisorActor.{ JobDispatcherName, StartAll, StopAll }
+
+class JobsSupervisorActor() extends Actor {
+
+  override val supervisorStrategy =
+    OneForOneStrategy() {
+      case _: ActorInitializationException ⇒ SupervisorStrategy.Stop
+      case _: ActorKilledException         ⇒ SupervisorStrategy.Stop
+      case _: DeathPactException           ⇒ SupervisorStrategy.Stop
+      case _: Exception                    ⇒ SupervisorStrategy.Resume
+    }
+
+  def receive: PartialFunction[Any, Unit] = {
+    case StartAll ⇒ ()
+    case StopAll  ⇒ ()
+  }
+}
+
+object JobsSupervisorActor {
+  case object StartAll
+  case object StopAll
+  val JobDispatcherName = "carjump-dispatcher"
+}

app/launch/CarjumpLoader.scala

@@ -0,0 +1,37 @@
+package launch
+
+import com.softwaremill.macwire._
+import controllers.Assets
+import play.api._
+import play.api.ApplicationLoader.Context
+import play.api.inject.Injector
+import play.api.libs.crypto.AESCTRCrypter
+import play.api.libs.logback.LogbackLoggerConfigurator
+import play.api.libs.ws.ahc.AhcWSComponents
+import play.api.routing.Router
+import router.Routes
+import util.SLF4JLogging
+
+class CarjumpLoader extends ApplicationLoader {
+  def load(context: Context): Application = {
+    LoggerConfigurator(context.environment.classLoader).foreach(_.configure(context.environment))
+
+    val module: BuiltInComponentsFromContext with CarjumpComponents = new BuiltInComponentsFromContext(context) with CarjumpComponents
+    module.startJobs()
+    module.application
+  }
+}
+
+trait CarjumpComponents extends BuiltInComponents with CarjumpModule with AhcWSComponents {
+
+  lazy val assets: Assets = wire[Assets]
+
+  lazy val router: Router = {
+    def prefixedRoutes(prefix: String): Routes = {
+      wire[Routes]
+    }
+    prefixedRoutes("/")
+  }
+
+  override implicit lazy val executionContext = actorSystem.dispatcher
+}

app/launch/CarjumpModule.scala

@@ -0,0 +1,37 @@
+package launch
+
+import scala.concurrent.{ ExecutionContext, Future, blocking }
+
+import clients.ClientsModule
+import controllers.ControllerModule
+import jobs.{ JobsModule, JobsSupervisorActor }
+import play.api.Configuration
+import play.api.inject.ApplicationLifecycle
+import services.ServicesModule
+import util.SLF4JLogging
+
+trait CarjumpModule
+    extends ControllerModule
+    with ServicesModule
+    with JobsModule
+    with ClientsModule
+    with SLF4JLogging {
+
+  def configuration: Configuration
+  def applicationLifecycle: ApplicationLifecycle
+  override implicit val executionContext: ExecutionContext
+
+  def startJobs(): Unit = {
+    jobsSupervisorActor ! JobsSupervisorActor.StartAll
+
+    // start jobs here
+
+    applicationLifecycle.addStopHook(() ⇒ stopActors())
+  }
+
+  private def stopActors(): Future[Unit] = {
+    Future {
+      jobsSupervisorActor ! JobsSupervisorActor.StopAll
+    }
+  }
+}

app/services/ServicesModule.scala

@@ -0,0 +1,16 @@
+package services
+
+import java.time.{ Clock, ZoneId }
+
+import scala.concurrent.ExecutionContext
+
+import play.api.Configuration
+
+trait ServicesModule {
+
+  implicit def configuration: Configuration
+
+  implicit val executionContext: ExecutionContext
+
+  lazy implicit val clock = Clock.system(ZoneId.of("Europe/Berlin"))
+}