How can i check if an Akka actor exists (akka 2.2)?

Question

I have a java object which is not an actor which selects actors from an actor system with actorSelection(Path)). It is possible, that the selected actor does not exist in the system.

In the Java Api ask() does not exist for ActorSelection, so I can not send and Identify message to the actor selection and use the sender of the response.

I tried to solve the problem by sending the message to the actor anyway via the actor selection and then reacting to the deadletter. But I don't get any deadletters.

How can I check with the ActorSelection if the actor is alive or does not exist?

ActorSystem system = ActorSystem.create("test");

//create test actor
system.actorOf(Props.create(TestActor.class), "testActor");

//add dead letter listener to the system
ActorRef eventBusActor = asys.actorOf(Props.create(EventBusActor.class), "eventbusactor");
system.eventStream().subscribe(eventBusActor, DeadLetter.class);


//This works. The test actor receives the message      
ActorSelection a1 = asys.actorSelection("/user/testActor");
a1.tell("hello", ActorRef.noSender());

//This does not work and does not send dead letters      
ActorSelection a2 = asys.actorSelection("/user/doesnotexist");
a2.tell("hello", ActorRef.noSender());

//Does not compile, because ask needs an ActorRef as first argument
ActorSelection a3 = asys.actorSelection("/user/test");
Future f = Patterns.ask(a3, new Identify(), 1000);

Answer 1

It looks like Akka left off support for ActorSelection on the java api for ask. I played with the code a little and I found something that works though. See if this code works for you:

import java.util.concurrent.TimeUnit;

import scala.concurrent.Await;
import scala.concurrent.Future;

import akka.actor.ActorIdentity;
import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import akka.actor.Identify;
import akka.actor.Props;
import akka.pattern.AskableActorSelection;
import akka.util.Timeout;

public class AskTest {

  public static void main(String[] args) throws Exception{
    ActorSystem sys = ActorSystem.apply("test");
    sys.actorOf(Props.create(TestActor.class), "mytest");

    ActorSelection sel = sys.actorSelection("/user/mytest");

    Timeout t = new Timeout(5, TimeUnit.SECONDS);
    AskableActorSelection asker = new AskableActorSelection(sel);
    Future<Object> fut = asker.ask(new Identify(1), t);
    ActorIdentity ident = (ActorIdentity)Await.result(fut, t.duration());
    ActorRef ref = ident.getRef();
    System.out.println(ref == null);
  }
}

I just looked at how the scala ask support worked and hooked into it via java. This worked for me; I'm hoping it works for you.

Answer 2

I recently found the ActorSelection.resolveOne method:

val name = "myActor"
implicit val timeout = 5000 // Timeout for the resolveOne call
system.actorSelection(name).resolveOne().onComplete {
  case Success(actor) => actor ! message

  case Failure(ex) =>
    val actor = system.actorOf(Props(classOf[ActorClass]), name)
    actor ! message
}

One problem I'm still investigating is, the method where this is defined might be called concurrently (from other actors). Therefore it's possible to get a race condition where you try to create the actor twice if the resolveOne call fails because the actor is still being created. This might or might not be an issue for your use case

Answer 3

Akka provides a functionality to get an ActorRef from an ActorSelection using a special message Identify. You don't have to use ask() for this message. Simply pass an Identify-message to the ActorSelection and listen for an ActorIdentity message that will be passed back to you. There is an example for exactly this in the Akka docs: Identifying Actors via Actor Selection (Java)

This code is taken from the example and modified:

final String identifyId = "1";

@Override
public void onReceive(Object message) {
    if (message instanceof ActorIdentity) {
        ActorIdentity identity = (ActorIdentity) message; 
        if (identity.correlationId().equals(identifyId)) {
            ActorRef ref = identity.getRef();
            if (ref == null)
                // Actor does not exist
            else {
                // Actor does exist
            }
        }
     }
}

There is also a very nice graphic that shows the relations between ActorPath, ActorSelection and the Actor Lifecycle in the docs.

Answer 4

As other answers note, ActorSelection.resolveOne() handles this.

One warning: Under the hood, this works by sending a message to the actor in question. Which means if that actor is busy, it won't reply, and this fails (with a timeout).

In pure-best-practice-Akka, this is probably a corner-case. In a more mixed normal-Java / Akka setup, it's easy to get snarled up though. In particular, code within an actor's thread cannot find a reference to that actor.

Answer 5

Using version 2.3.4

Some Scala example, maybe can help

  val zed2 = Akka.system().actorSelection("path")
  val fs:FiniteDuration = (100).millis

  val x = zed2.resolveOne(fs).value
  if (x.isDefined){
    println(x.get.isFailure)
  }