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 GetBlockIOExcutor with ActorSystemApi {
  val longTimeout = Timeout(ConstVars.longTimeOut)

  lazy val doradillaConfig = DoraCoreConfig.getConfig()

  def createDoradillaSystem: ActorSystem = {
    val actorSystemName = ConfigService.getStringOpt(doradillaConfig, "doradillaSystem").getOrElse(CNaming.timebasedName( "diradilla"))
    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)
  }
}