Akka: Can an actor of some class become an actor of a diferent class?

Question

As a course project, I am trying to implement a (simulation) of the Raft protocol. In this post, I will not use Raft terminology at all; instead, I will use a simplified one.

The protocol is run by a number of servers (for example, 5) which can be in three different states (A, B, C). The servers inherit some state variables and behavior from a "base" kind, but they all also have many unique state variables and methods, and respond to different messages. At some point of the protocol, a server in some state (for example, A) is required to become the other state (for example, B). In other words, the server should:

1. Lose the state variables and methods of state A, acquire those of state B, but maintain the variables of the "base" kind.
2. Stop responding to messages destined for state A, start responding to messages destined for state B.

In Akka, Point 1 can be implemented using Receives and become().

Point 2 is needed because, for example, an actor of class B should not have access to state variables and methods of an actor of class A. This aims at separating concerns, and achieving a better code organization.

The issues I am facing in implementing these Point 2 are the following:

• Right now, my implementation has only one actor, which contains both A and B state variables and methods.
• The protocol I am trying to implement requires each server has to keep a reference to the others (i.e., the ActorRef of the others).
• I can't simply spawn an actor in state B, transfer the values of the state variables of the "base" kind to it, and stop the old actor, because the newly spawned actor has a new ActorRef, and the other servers are in the dark about it, and they will continue sending messages using the old ActorRef (therefore, the new actor would not receive anything, and both parties time out).

A way to circumvent the issue is that the newly spawned actor "advertises" itself by sending a message to the other actors, including its old ActorRef. However, again due to the protocol, the other servers may be temporarily not available (i.e., they are crashed), thus they might not receive and process the advertisement.

In the project, I must use extensions of AbstractActor, and not FSM (final state machines), and have to use Java.

Is there any Akka pattern or functionality that solves this use case? Thank you for any insight. Below is a simplified example.

public abstract class BaseActor extends AbstractActor {
    protected int x = 0;
    // some state variables and methods that make sense for both A and B

    @Override
    public Receive createReceive() {
        return new ReceiveBuilder()
                .matchEquals("x", msg -> {
                    System.out.println(x);
                    x++;
                })
                .build();
    }
}

public class A extends BaseActor {
    protected int a = 10;
    // many other state variables and methods that are own of A and do NOT make sense to B

    @Override
    public Receive createReceive() {
        return new ReceiveBuilder()
                .matchEquals("a", msg -> {
                    System.out.println(a);
                })
                .matchEquals("change", msg -> {
                    // here I want A to become B, but maintain value of x
                })
                .build()
                .orElse(super.createReceive());
    }
}

public class B extends BaseActor {
    protected int b = 20;
    // many other state variables and methods that are own of B and do NOT make sense to A

    @Override
    public AbstractActor.Receive createReceive() {
        return new ReceiveBuilder()
                .matchEquals("b", msg -> {
                    System.out.println(b);
                })
                .matchEquals("change", msg -> {
                    // here I want B to become A, but maintain value of x
                })
                .build()
                .orElse(super.createReceive());
    }
}

public class Example {
    public static void main(String[] args) {
        var system = ActorSystem.create("example");

        // actor has class A
        var actor = system.actorOf(Props.create(A.class));
        actor.tell("x", ActorRef.noSender()); // prints "0"
        actor.tell("a", ActorRef.noSender()); // prints "10"

        // here, the actor should become of class B,
        // preserving the value of x, a variable of the "base" kind
        actor.tell("change", ActorRef.noSender());

        // actor has class B
        actor.tell("x", ActorRef.noSender()); // should print "1"
        actor.tell("b", ActorRef.noSender()); // should print "20"
    }
}

Answer 1

This is a sketch implementation of how this could look like.

1. You model each of the states a separate class:

public class BaseState {
  //base state fields/getters/setters
}

public class StateA {
  BaseState baseState;
  //state A fields/getters/setters
  ..

  //factory methods
  public static StateA fromBase(BaseState baseState) {...}

  //if you need to go from StateB to StateA:
  public static StateA fromStateB(StateB stateB) {...}
}

public class StateB {
  BaseState baseState;
  //state B fields/getters/setters

  //factory methods
  public static StateB fromBase(BaseState baseState) {...}

  //if you need to go from StateA to StateB:
  public static StateB fromStateA(StateA stateA) {...}
}

2. Then in your Actor you can have receive functions defined for both A and B and initialize it to A or B depending which one is the initial one

private static class MyActor extends AbstractActor
  {
    private AbstractActor.Receive receive4StateA(StateA stateA)
    {
      return new ReceiveBuilder()
        .matchEquals("a", msg -> stateA.setSomeProperty(msg))
        .matchEquals("changeToB", msg -> getContext().become(
          receive4StateB(StateB.fromStateA(stateA))))
        .build();
    }

    private AbstractActor.Receive receive4StateB(StateB stateB)
    {
      return new ReceiveBuilder()
        .matchEquals("b", msg -> stateB.setSomeProperty(msg))
        .matchEquals("changeToA", msg -> getContext().become(
          receive4StateA(StateA.fromStateB(stateB))))
        .build();
    }

    //assuming stateA is the initial state
    @Override
    public AbstractActor.Receive createReceive()
    {
      return receive4StateA(StateA.fromBase(new BaseState()));
    }
  }

Answer 2

Admittedly, my Java is rusty, but for example, this actor (or something very much like it...) will take strings until it receives a Lock message, after which it can be queried for how many distinct strings it received before being locked. So in the first Receive it gets, it tracks a Set of the strings received in order to dedupe. On a Lock it transitions to a second Receive which does not contain the Set (just an Integer field) and ignores String and Lock messages.

import akka.japi.JavaPartialFunction;
import java.util.HashSet;
import scala.runtime.BoxedUnit;

public class StringCounter extends AbstractActor {
  public StringCounter() {}

  public static class Lock {
    private Lock() {}
    public static final Lock INSTANCE = new Lock();
  }

  public static class Query {
    private Query() {}
    public static final Query INSTANCE = new Query();
  }

  /** The taking in Strings state */
  public class AcceptingStrings extends JavaPartialFunction<Object, BoxedUnit> {
    private HashSet<String> strings;

    public AcceptingStrings() {
      strings = new HashSet<String>();
    }

    public BoxedUnit apply(Object msg, boolean isCheck) {
      if (msg instanceof String) {
        if (!isCheck) {
          strings.add(msg);
        }
      } else if (msg instanceof Lock) {
        if (!isCheck) {
          context().become(new Queryable(strings.size()), true);
        }
      } else {
        // not handling any other message
        throw noMatch();
      }

      return BoxedUnit.UNIT;
    }
  }

  /** The responding to queries state */
  public class Queryable extends JavaPartialFunction<Object, BoxedUnit> {
    private Integer ans;

    public Queryable(int answer) {
      ans = Integer.valueOf(answer);
    }

    public BoxedUnit apply(Object msg, boolean isCheck) {
      if (msg instanceof Query) {
        if (!isCheck) {
          getSender().tell(ans, getSelf());
        }
      } else {
        // not handling any other message
        throw noMatch();
      }

      return BoxedUnit.UNIT;
    }
  }

  @Override
  public Receive createReceive() {
    return new Receive(new AcceptingStrings());
  }
}

Note that in Queryable the set is long gone. One thing to be careful of is that the JavaPartialFunction will typically have apply called once with isCheck set to true and if that call doesn't throw the exception returned by noMatch(), it will be called again "for real" with isCheck set to false. You therefore need to be careful to not do anything but throw noMatch() or return in the case that isCheck is true.

This pattern is exceptionally similar to what happens in Akka Typed (especially in the functional API) under the hood.

Hopefully this illuminates this approach. There's a chance, of course, that your instructors will not accept this, though in that case it might be worth pushing back with the argument that:

• in the actor model state and behavior are effectively the same thing
• all the functionality is contained within an AbstractActor

I'd also not necessarily recommend using this approach normally in Java Akka code (the AbstractActor with state in its fields feels a lot more Java-y).