Play framework with Akka and WS

Play framework with Akka and WS

1 Set Up Akka in Playframework
In my controller which I believe it is single, I set up the AKKA system.
package controllers

import actors._
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 com.wordnik.swagger.annotations._
import models.ScanTriggerRequest
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 scala.concurrent.duration._
import com.wordnik.swagger.annotations._

object ScanTriggerController extends Controller with IncludeLogger with IncludeWSConfig{

  implicit val scanTriggerWrites = Json.writes[ScanTriggerRequest]
  implicit val scanTriggerReads = Json.reads[ScanTriggerRequest]

  Akka.system.actorOf(JobParseActor.props, name = "job-parse-actor")

  Akka.system.actorOf(JobServiceActor.props, name = "job-service-actor")

  Akka.system.actorOf(ResumeAttachActor.props, name = "resume-attach-actor")

  Akka.system.actorOf(ResumeParseActor.props, name = "resume-parse-actor")

  Akka.system.actorOf(ResumeServiceActor.props, name = "resume-service-actor")

  Akka.system.actorOf(TriggerActor.props, name = "trigger-actor")

  val contextIOActor = Akka.system.actorOf(ContextIOActor.props, name = "contextio-actor")

  val contextIOThrottler = Akka.system.actorOf(Props(classOf[TimerBasedThrottler], contextio_throttle msgsPer 60.second), name = "conetxt-io-throttler")

  contextIOThrottler ! SetTarget(Some(contextIOActor))

  def trigger = Action(BodyParsers.parse.json) { request =>
    val b = request.body.validate[ScanTriggerRequest]
    logger.debug("Processing request with param = " + request.body)
    b.fold(
      errors => {
        BadRequest(Json.obj("status" -> "OK", "message" -> JsError.toJson(errors)))
      },
      trigger => {
        //TODO more validation on the params
        logger.debug("Param validation success, param = " + trigger)

        val triggerActor = Akka.system.actorSelection("/user/trigger-actor")
        logger.debug("Prepare the trigger action = " + triggerActor + ", and fire message!")
        triggerActor ! trigger
        Ok(Json.obj("status" -> "OK"))
      }
    )
  }

}

In any other actors or any other controllers, we can do as follow:
val jobServiceActor = context.actorSelection("/user/job-service-actor")
jobServiceActor ! JobContentPersistMessage(msg.jobId, jobCity, msg.emailContent)

In my case I have one controller to trigger my actions, maybe in the future I need to set up the AKKA system in global class or some where.

2 WS to call other Micro Service
Here is how I call other micro service
import akka.actor.{Actor, Props}
import com.sillycat.dao.{DAO, IpplyJobDAO, ResumeDAO}
import com.sillycat.util.IncludeLogger
import models.messages.jobs.{JobPersistMessage, JobScanMessage, JobContentParseMessage, JobContentScanMessage}
import models.messages.resumes._
import models.{ResumeScanResponse, ResumeScanAttachmentResponse, JobContentResponse, JobScanResponse}
import play.api.libs.json.Json
import play.api.libs.ws.{WS, WSResponse}
import utils.IncludeRegex
import play.api.Play.current
import scala.concurrent.ExecutionContext.Implicits.global

import scala.concurrent.Future
…snip...
    case msg:JobContentScanMessage => {
      logger.debug("receiving the message JobContentScanMessage" + msg)
      //context.io fetch job content, actually it is email content, I need the city and location info
      val future:Future[WSResponse] = WS.url(contextio_host + "/jobs/" + msg.accountCode +"/" + msg.messageCode ).get()
      //scan jobs success
      future onSuccess {
        case response if response.status == 200 => {
          logger.trace("Scanning job content = " + response.json)

          response.json.asOpt[JobContentResponse].map { job =>
            logger.trace("Scanning result job content = " + job)
            val jobContentParseMessage = JobContentParseMessage(msg.jobId, job.content)
            logger.debug("fire the message to job-parse-actor to parse email content.")
            jobParseActor ! jobContentParseMessage
          }
        }
        case response => {
          //handling error
          logger.error("Error handle with status = " + response.status + " message = " + response.body)
        }
      }
      //scan jobs fail
      future onFailure {
        case t => logger.error("An error has occured: " + t.getMessage)
      }
    }

For post
      val request_data = Json.obj(
        "provider" -> "CRAIGSLIST",
        "accountCode" -> msg.accountCode,
        "dateBefore" -> msg.dateBefore.toString(default_date_time_format),
        "dateAfter" -> msg.dateAfter.toString(default_date_time_format),
        "limit" -> msg.limit,
        "offset" -> msg.offset
      )
      logger.debug("Send json request parameter = " + request_data)
      val future:Future[WSResponse] = WS.url(contextio_host + "/jobs/scan").post(request_data)

References:
https://www.playframework.com/documentation/2.4.3/ScalaWS
https://www.playframework.com/documentation/2.4.3/ScalaAkka

akka system
http://sillycat.iteye.com/blog/1767866
http://sillycat.iteye.com/blog/1768625
http://sillycat.iteye.com/blog/1768626
http://sillycat.iteye.com/blog/2099267
http://sillycat.iteye.com/blog/2100232
http://sillycat.iteye.com/blog/2102694
http://sillycat.iteye.com/blog/2175999