Play framework Timer and Scheduler

Play framework Timer and Scheduler

1 Global Setting Up and Akka Scheduler for Actors
I create a scala application here Global.scala
import actors._
import actors.jobs.{JobServiceActor, JobParseActor}
import actors.resumes.{ResumeServiceActor, ResumeParseActor, ResumeAttachActor}
import actors.jobs.{JobServiceActor, JobParseActor}
import actors.resumes.{ResumeServiceActor, ResumeParseActor, ResumeAttachActor}
import akka.actor.Props
import com.sillycat.dao.{IpplyJobDAO, DAO}
import com.sillycat.util.IncludeLogger
import play.api.libs.concurrent.Akka
import play.api.libs.json.{JsError, Json}
import play.api.mvc.{BodyParsers, Action, Controller}
import play.api.Play.current
import akka.contrib.throttle.TimerBasedThrottler
import akka.contrib.throttle.Throttler._
import utils.IncludeWSConfig
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

object Global extends  play.api.GlobalSettings with IncludeLogger with IncludeWSConfig{

  override def onStart(app: play.api.Application) {
    logger.info("Start Email Scan Application")
    logger.info("init all the actors -------------")
    Akka.system.actorOf(JobParseActor.props, name = "job-parse-actor")
    logger.trace("job parse actor")
    Akka.system.actorOf(JobServiceActor.props, name = "job-service-actor")
    logger.trace("job service actor")
    Akka.system.actorOf(ResumeAttachActor.props, name = "resume-attach-actor")
    logger.trace("resume attach actor")
    Akka.system.actorOf(ResumeParseActor.props, name = "resume-parse-actor")
    logger.trace("resume parse actor")
    Akka.system.actorOf(ResumeServiceActor.props, name = "resume-service-actor")
    logger.trace("resume service actor")
    Akka.system.actorOf(ParseCOMWebHookActor.props, name= "parse-com-webhook-actor")
    logger.trace("parse.com web hook actor")
    Akka.system.actorOf(TriggerActor.props, name = "trigger-actor")
    logger.trace("trigger actor")
    Akka.system.actorOf(AccountServiceActor.props, name = "account-service-actor")
    logger.trace("account service actor")
    val contextIOActor = Akka.system.actorOf(ContextIOActor.props, name = "contextio-actor")
    logger.trace("contextio actor")
    val contextIOThrottler = Akka.system.actorOf(Props(classOf[TimerBasedThrottler], contextio_throttle_times msgsPer contextio_throttle_duration.second), name = "context-io-throttler")
    contextIOThrottler ! SetTarget(Some(contextIOActor))
    logger.trace("throttler actor")
    val schedulerSyncActor = Akka.system.actorOf(SchedulerSyncActor.props, name = "scheduler-sync-actor")
    logger.trace("scheduler sync actor")
    logger.info("---------------------------------done")
    logger.info(" ")

    Comments out the sync logic after having meeting with context.io
    logger.info("init the schedule jobs-----------")
    Akka.system.scheduler.schedule(
          0 seconds,
          contextio_sync_interval seconds,
          schedulerSyncActor,
          "fire-in-the-hole"
        )
    logger.info("schedulerSyncActor executing every " + contextio_sync_interval + " seconds")
    logger.info("---------------------------------done")
  }
}

Usually, I can put the codes to start up the actors there. Also the scheduler of Actors is also there. Then every time, the scheduler will call the actors.

2 Timer and Schedule for Methods
package actors

import java.util.concurrent.{ConcurrentHashMap, TimeUnit}
import java.util.{TimerTask, Timer}

import akka.actor.{Props, Actor}
import akka.contrib.throttle.Throttler.SetTarget
import com.google.common.cache.CacheBuilder
import com.sillycat.util.{IncludeConfig, IncludeLogger}
import models.messages.webhooks.{SyncMessage, WebhookMessage}
import models._
import models.messages.jobs.JobScanMessage
import models.messages.resumes.ResumeScanMessage
import org.joda.time.DateTime
import play.api.libs.json.{Writes, Reads, Json}
import play.api.libs.ws.{WSResponse, WS}
import play.api.Play.current
import utils.IncludeWSConfig
import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import concurrent.duration._
import scala.collection._
import scala.collection.convert.decorateAsScala._
import java.util.concurrent.ConcurrentHashMap

object TriggerActor {
  def props = Props[TriggerActor]
}

class TriggerActor  extends Actor with IncludeLogger with IncludeWSConfig {
  implicit val jodaDateReads = Reads.jodaDateReads("yyyy-MM-dd HH:mm:ss")
  implicit val jodaDateWrites = Writes.jodaDateWrites("yyyy-MM-dd HH:mm:ss")

  implicit val contextSyncStatusResponseWrites = Json.writes[ContextSyncStatusResponse]
  implicit val contextSyncStatusResponseReads = Json.reads[ContextSyncStatusResponse]

  val contextIOthrottler = context.actorSelection("/user/context-io-throttler")
  val accountServiceActor = context.actorSelection("/user/account-service-actor")
  val maxDwellInMinutes = 120
  val maxRetries = 100
  val TASK_LIST_KEY = "TASK_SYNC_LIST"
  val MAX_RETRY_LIST_KEY = "TASK_RETRY_MAX_LIST"
  val timer = new Timer(true)
  timer.schedule(new TimerTask {
    def run() = {
      checkSyncBatch()
    }
  }, 0, 120000) // deplay - 0 milliseconds, period 2 * 60 * 1000 milliseconds

  val builder = CacheBuilder.newBuilder().expireAfterWrite(maxDwellInMinutes, TimeUnit.MINUTES)
  val taskBucket = builder.build[java.lang.String, ConcurrentHashMap[String,ScanTriggerRequest]]()
  val retriesBucket = builder.build[java.lang.String, ConcurrentHashMap[String,Int]]()
  val initMap = new ConcurrentHashMap[String,ScanTriggerRequest]()
  val retriesMap = new ConcurrentHashMap[String, Int]()
  taskBucket.put(TASK_LIST_KEY, initMap)
  retriesBucket.put(MAX_RETRY_LIST_KEY, retriesMap)

  def receive = {
     …snip...
}

  def checkSyncBatch() = {
    logger.info("Checking the sync status every period time..." + DateTime.now.toString(default_date_time_format))

    //fetch the list from cache
    val taskMap = taskBucket.getIfPresent(TASK_LIST_KEY)

    if(taskMap != null && !taskMap.isEmpty){
      //check sync
      val removeTasks = taskMap.asScala.filter { case(key:String, msg:ScanTriggerRequest) =>
        val dateBefore = handleDateBefore(msg.dateBefore)
        checkSync(msg.accountCode, dateBefore)
      }

      //remove the synced task
      removeTasks.foreach { case(key:String, v:ScanTriggerRequest) =>
        //remove
        taskMap.remove(key)
        val msg = v
        val dateBefore = handleDateBefore(msg.dateBefore)
        val dateAfter = handleDateAfter(msg.dateAfter)
        //fireMessage
        contextIOthrottler ! JobScanMessage(v.accountCode,dateBefore, dateAfter,default_paging_num_of_item, 0)
        contextIOthrottler ! ResumeScanMessage(v.accountCode, dateBefore, dateAfter, default_paging_num_of_item, 0)
      }
      //remove all the max task
      val maxMap = retriesBucket.getIfPresent(MAX_RETRY_LIST_KEY)
      if(maxMap != null && !maxMap.isEmpty){
        val removeMax = maxMap.asScala.filter { case(key:String, count: Int)=>
          count > maxRetries
        }
        removeMax.foreach{ case (removeKey:String, count: Int) =>
          taskMap.remove(removeKey)
          maxMap.remove(removeKey)
        }
      }
      retriesBucket.put(MAX_RETRY_LIST_KEY, maxMap)
      taskBucket.put(TASK_LIST_KEY, taskMap)
    }
  }
  …snip...
}

References:
http://sillycat.iteye.com/