Slick database access in Actor - scala

Question

I have a play-scala application using SqLite with slick. My tables are defined like this:
#Singleton
class DataSets #Inject()(protected val dbConfigProvider: DatabaseConfigProvider, keys: PublicKeys) extends DataSetsComponent
with HasDatabaseConfigProvider[JdbcProfile] {
import driver.api._
val DataSets = TableQuery[DataSetsTable]
def all = db.run(DataSets.sortBy { _.id }.result)
...
}
My controllers get access via DI:
#Singleton
class DataSetsController #Inject() (dataSets: DataSets, env: play.Environment) extends Controller {
...
How do I get a database handle in an Actor?
class TrainActor #Inject() (dataSets: DataSets) extends Actor {
...
of course does not work as Guice does not find the DataSets class.
Edit: to clarify: I do not want to use the actor for database access in the controller (via ask), but to start some resource intensive computations from the controller after a request and store them in the db afterwards (async).

Answer 1

I now found a way which integrates with DI, closely following the official documentation. Because for the need of an ActorContext, InjectedActorSupport can only be inherited by Actors. This means I had to create an actor which does nothing than instantiate and start new "worker" Actors. Maybe there is an easier way, but this works correctly.
TrainActor.scala:
package actors
import javax.inject.Inject
import akka.actor._
import com.google.inject.assistedinject.Assisted
import models.{DataSet, Model, PublicKey}
import play.api.Logger
import tables.DataSets
import scala.concurrent.ExecutionContext.Implicits.global
object TrainActor {
case object Start
case class LoadData(d: DataSet, k: PublicKey)
trait Factory {
def apply(model: Model): Actor
}
}
class TrainActor #Inject() (val dataSets: DataSets, #Assisted val model: Model) extends Actor {
import TrainActor._
def receive = {
case Start =>
dataSets.findWithKey(model.id.get)
...
TrainActorStarter.scala:
package actors
import javax.inject.Inject
import akka.actor.{Actor, ActorRef}
import models.Model
import play.api.libs.concurrent.InjectedActorSupport
object TrainActorStarter {
case class StartTraining(model: Model)
}
/**
* https://www.playframework.com/documentation/2.5.x/ScalaAkka#Dependency-injecting-actors
* #param childFactory
*/
class TrainActorStarter #Inject() (childFactory: TrainActor.Factory) extends Actor with InjectedActorSupport {
import TrainActorStarter._
def receive = {
case StartTraining(model: Model) =>
val trainer: ActorRef = injectedChild(childFactory(model), s"train-model-model-${model.id.get}")
trainer ! TrainActor.Start
}
}
ActorModule.scala:
package actors
import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport
class ActorModule extends AbstractModule with AkkaGuiceSupport {
def configure(): Unit = {
bindActor[TrainActorStarter]("train-actor-starter")
bindActorFactory[TrainActor, TrainActor.Factory]
}
}
And finally in the controller:
package controllers
import javax.inject._
import actors.{TrainActorStarter, TrainCallbackActor}
import akka.actor.{ActorRef, ActorSystem, _}
import akka.stream.Materializer
...
#Singleton
class ModelsController #Inject() (implicit system: ActorSystem, materializer: Materializer, ..., #Named("train-actor-starter") trainActorStarter: ActorRef) extends Controller with InjectedActorSupport {
def startTraining(model: Model): Unit = {
if(model.id.isEmpty) return
trainActorStarter ! TrainActorStarter.StartTraining(model)
}

Answer 2

You can inject dependencies into an actor:
import com.google.inject.AbstractModule
import play.api.libs.concurrent.AkkaGuiceSupport
class MyModule extends AbstractModule with AkkaGuiceSupport {
def configure = {
bindActor[TrainActor]("injected-train-actor")
}
}
After that just inject actor into controller:
class MyController #Inject()(#Named("injected-train-actor") trainActor: ActorRef) {
def endpointTest = Action.async {
for {
items <- (trainActor ? FetchAll).mapTo[Seq[DataSetsTableRow]]
} yield Ok(Json.toJson(items))
}
}

Answer 3

Instead of having
#Singleton
class DataSets
one can declare it as a simple scala object that can act as the DataSetsDAO
object DataSets
and then in the actor just use DataSets.dbOperation just bear in mind that the result type of that will be a Future, so just schedule a message to self in the actor on the onComplete to avoid any side effects.