Akka：将错误从路由发回给呼叫者

Question

In my project, I created UserRepositoryActor which create their own router with 10 UserRepositoryWorkerActor instances as routee, see hierarchy below:

As you see, if any error occur while fetching data from database, it will occur at worker.

Once I want to fetch user from database, I send message to UserRepositoryActor with this command:

val resultFuture = userRepository ? FindUserById(1)

and I set 10 seconds for timeout.

In case of network connection has problem, UserRepositoryWorkerActor immediately get ConnectionException from underlying database driver and then (what I think) router will restart current worker and send FindUserById(1) command to other worker that available and resultFuture will get AskTimeoutException after 10 seconds passed. Then some time later, once connection back to normal, UserRepositoryWorkerActor successfully fetch data from database and then try to send result back to the caller and found that resultFuture was timed out.

I want to propagate error from UserRepositoryWorkerActor up to the caller immediately after exception occur, so that will prevent resultFuture to wait for 10 seconds and stop UserRepositoryWorkerActor to try to fetch data again and again.

How can I do that?

By the way, if you have any suggestions to my current design, please suggest me. I'm very new to Akka.

Answer 1

Your assumption about Router resending the message is wrong. Router has already passed the message to routee and it doesnt have it any more.

As far as ConnectionException is concerned, you could wrap in a scala.util.Try and send response to sender() . Something like,

Try(SomeDAO.getSomeObjectById(id)) match {
    case Success(s) => sender() ! s
    case Failure(e) => sender() ! e
  }

Answer 2

You design looks correct. Having a router allows you to distribute work and also to limit number of concurrent workers accessing the database.

Option 1

You can make your router watch its children and act accordingly when they are terminated. For example (taken from here ):

import akka.routing.{ ActorRefRoutee, RoundRobinRoutingLogic, Router }

class Master extends Actor {
  var router = {
    val routees = Vector.fill(5) {
      val r = context.actorOf(Props[Worker])
      context watch r
      ActorRefRoutee(r)
    }
    Router(RoundRobinRoutingLogic(), routees)
  }

  def receive = {
    case w: Work =>
      router.route(w, sender())
    case Terminated(a) =>
      router = router.removeRoutee(a)
      val r = context.actorOf(Props[Worker])
      context watch r
      router = router.addRoutee(r)
  }
}

In your case you can send some sort of a failed message from the repository actor to the client. Repository actor can maintain a map of worker ref to request id to know which request failed when worker terminates. It can also record the time between the start of the request and actor termination to decide whether it's worth retrying it with another worker.

Option 2

Simply catch all non-fatal exceptions in your worker actor and reply with appropriate success/failed messages. This is much simpler but you might still want to restart the worker to make sure it's in a good state.

ps Router will not restart failed workers, neither it will try to resend messages to them by default. You can take a look at supervisor strategy and Option 1 above on how to achieve that.