scala - Riproduci 2.5 con Akka: impossibile trovare un valore implicito per il timeout dei parametri: akka.util.Timeout



playframework (1)

Sto tentando di testare Akka con Play 2.5 e sto correndo un errore di compilazione che non riesco a capire.

Sto seguendo questa pagina dalla documentazione di Play: https://playframework.com/documentation/2.5.x/ScalaAkka

Ecco il codice completo:

package controllers

import javax.inject.{Inject, Singleton}
import akka.actor.ActorSystem
import controllers.HelloActor.SayHello
import play.api.mvc._
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import scala.concurrent.duration._
import akka.pattern.ask

@Singleton
class Application @Inject()(system: ActorSystem) extends Controller {

  implicit val timeout = 5.seconds

  val helloActor = system.actorOf(HelloActor.props, "hello-actor")

  def sayHello(name: String) = Action.async {
    (helloActor ? SayHello(name)).mapTo[String].map { message =>
      Ok(message)
    }
  }
}

import akka.actor._

object HelloActor {
  def props = Props[HelloActor]

  case class SayHello(name: String)

}

class HelloActor extends Actor {
  import HelloActor._

  def receive = {
    case SayHello(name: String) =>
      sender() ! "Hello, " + name
  }
}

Il mio percorso sembra:

GET     /:name                      controllers.Application.sayHello(name: String)

E, infine, il mio build.sbt:

name := "AkkaTest"

version := "1.0"

lazy val `akkatest` = (project in file(".")).enablePlugins(PlayScala)

scalaVersion := "2.11.7"

libraryDependencies ++= Seq( jdbc , cache , ws   , specs2 % Test )

unmanagedResourceDirectories in Test <+=  baseDirectory ( _ /"target/web/public/test" )  

resolvers += "scalaz-bintray" at "https://dl.bintray.com/scalaz/releases"

routesGenerator := InjectedRoutesGenerator

Quando provo a eseguire ciò, ottengo il seguente errore di compilazione:

could not find implicit value for parameter timeout: akka.util.Timeout

Ho provato a spostare il timeout senza successo. Qualcuno ha un'idea di cosa potrebbe causare questo errore di compilazione?


Si ottiene questo errore perché il modello di richiesta richiede un timeout implicito per la richiesta (verrà completato in futuro con TimeoutException se non è stata ricevuta alcuna risposta per questa volta). Quindi tutto ciò che serve è creare un valore locale implicito nel metodo sayHello in questo modo:

import akka.util.Timeout
import scala.concurrent.duration.Duration

// ...

  def sayHello(name: String) = Action.async {
    implicit val timeout: Timeout = Duration.Infinite
    (helloActor ? SayHello(name)).mapTo[String].map { message =>
      Ok(message)
    }
  }

Invece di specificare il timeout infinito, puoi specificare uno finito con la seguente sintassi:

import scala.concurrent.duration._
import akka.util.Timeout

implicit val duration: Timeout = 20 seconds




akka