JobApi

What’s JobApi

JobApi is an interface and mixin of implementation of key functions in doradilla.

Let’s see what’s JobApi:

package doracore.api

import akka.actor.ActorSystem

/** For doradilla.api in Doradilla
  * Created by whereby[Tao Zhou](187225577@qq.com) on 2019/4/13
  */
class JobApi(systemOpt: Option[ActorSystem] = None)
    extends SystemApi(systemOpt: Option[ActorSystem])
    with DriverApi
    with CommandTranApi
    with ProcessTranApi {}

The Job Api mixin SystemApi, DriverApi and TranslationApi(CommmandTranApi and ProcessTranApi).

When create a JobApi:

1. If no AkkaSystem is passed in, there will create a AkkaSystem; if an AkkaSystem is passed in, the AkkaSystem will be used. [SystemApi]

2. A DriveActor will be created in the AkkaSystem. And a QueueActor will created by the DriverActor. A FSMActor will be created and linked to the QueueActor [DriverApi]

3. Some default TranslationActor(CommandTranActor, ProcessTranActor) will be created.[CommandTranApi, ProcessTranApi]

Code implementation:

SystemApi

package doracore.api

import akka.actor.ActorSystem
import akka.util.Timeout
import doracore.util.{CNaming, ConfigService, DoraCoreConfig}
import doracore.vars.ConstVars

/** For doradilla.api in Doradilla
  * Created by whereby[Tao Zhou](187225577@qq.com) on 2019/4/9
  */
class SystemApi(systemOpt: Option[ActorSystem] = None)
    extends GetBlockIOExecutor
    with ActorSystemApi {
  val longTimeout = Timeout(ConstVars.longTimeOut)

  lazy val doradillaConfig = DoraCoreConfig.getConfig()

  def createDoradillaSystem: ActorSystem = {
    val actorSystemName = ConfigService
      .getStringOpt(doradillaConfig, "doradillaSystem")
      .getOrElse(CNaming.timebasedName("doradilla"))
    ActorSystem(actorSystemName, doradillaConfig)
  }

  override def getActorSystem(): ActorSystem = {
    actorSystem
  }

  val actorSystem: ActorSystem = systemOpt match {
    case Some(system) => system
    case _            => createDoradillaSystem
  }
}

DriverApi

package doracore.api

import akka.actor.{ActorRef}
import doracore.core.driver.DriverActor
import doracore.util.{CNaming, ConfigService}

/** For doradilla.api in Doradilla
  * Created by whereby[Tao Zhou](187225577@qq.com) on 2019/4/9
  */
trait DriverApi {
  this: SystemApi =>
  def createDriver(
      queueActorOpt: Option[ActorRef] = None,
      driverNameOpt: Option[String] = None
  ): ActorRef = {
    val driverName = driverNameOpt match {
      case Some(driverName) => driverName
      case _ =>
        ConfigService
          .getStringOpt(doradillaConfig, "driverPrefix")
          .getOrElse(CNaming.timebasedName("driver"))
    }
    actorSystem.actorOf(DriverActor.driverActorProps(queueActorOpt), driverName)
  }

  var queueActorSet: Option[ActorRef] = None

  lazy val defaultDriver: ActorRef = createDriver(queueActorSet)
}

CommandTranApi

package doracore.api

import doracore.core.msg.Job.{JobMsg, JobRequest, JobResult}
import doracore.tool.job.command.CommandTranActor
import doracore.tool.job.command.CommandTranActor.CommandRequest
import doracore.tool.receive.ReceiveActor
import play.api.libs.json.Json
import scala.concurrent.{ExecutionContext, Future}
import akka.util.Timeout
import doracore.util.CNaming

/** For doradilla.api in Doradilla
  * Created by whereby[Tao Zhou](187225577@qq.com) on 2019/4/13
  */
trait CommandTranApi extends AskProcessResult {
  this: SystemApi with DriverApi =>
  val commandTranslatedActor =
    actorSystem.actorOf(CommandTranActor.commandTranProps, CNaming.timebasedName("CommandTran"))

  def processCommand(command: List[String], timeout: Timeout = longTimeout)(implicit
      ex: ExecutionContext
  ): Future[JobResult] = {
    val commandJobMsg = JobMsg("SimpleCommand", Json.toJson(CommandRequest(command)).toString())
    val receiveActor =
      actorSystem.actorOf(ReceiveActor.receiveActorProps, CNaming.timebasedName("Receive"))
    val commandJobRequest = JobRequest(commandJobMsg, receiveActor, commandTranslatedActor)
    getProcessCommandFutureResult(commandJobRequest, defaultDriver, receiveActor, timeout)
  }
}

ProcessTranApi

package doracore.api

import doracore.core.msg.Job.{JobMsg, JobRequest, JobResult}
import doracore.tool.job.process.ProcessTranActor
import doracore.tool.receive.ReceiveActor
import doracore.util.ProcessService.ProcessCallMsg

import scala.concurrent.{ExecutionContext, Future}
import akka.util.Timeout
import doracore.util.CNaming

/** For doradilla.api in Doradilla
  * Created by whereby[Tao Zhou](187225577@qq.com) on 2019/4/24
  */
trait ProcessTranApi extends AskProcessResult {
  this: SystemApi with DriverApi =>
  val processTranActor = actorSystem.actorOf(
    ProcessTranActor.processTranActorProps,
    CNaming.timebasedName("defaultProcessTranActor")
  )

  def runProcessCommand(processCallMsg: ProcessCallMsg, timeout: Timeout = longTimeout)(implicit
      ex: ExecutionContext
  ): Future[JobResult] = {
    val processJob = JobMsg("SimpleProcess", processCallMsg)
    val receiveActor =
      actorSystem.actorOf(ReceiveActor.receiveActorProps, CNaming.timebasedName("Receive"))
    val processJobRequest = JobRequest(processJob, receiveActor, processTranActor)
    getProcessCommandFutureResult(processJobRequest, defaultDriver, receiveActor, timeout)
  }
}