Instances de machines à états finis Akka

Question

Je suis en train d'essayer de tirer parti de Akka de la machine à états finis cadre pour mon cas d'utilisation. Je suis en train de travailler sur un système qui traite une demande qui va à travers différents états.

La demande ici, c'est le nom de l'application qui doit être déployé avec l'application, il dépend de:

Request for application A -> A is in a QUEUED state
Discover A's dependency B -> B is in a QUEUED state
B is being processed -> B is in a PROCESSING STATE
A is being processed -> A is in a PROCESSING STATE
B is processed -> B is in a DONE state
A is processed -> A is in a DONE state

Pour cela, je suis de l'initialisation d'une machine à état fini au moment de la découverte. Donc, As'FSM est créé lorsque la demande vient, Bs'FSM est initialisé lors de la B sont issus de l'un des acteurs.

Dois-je initialiser et passer le FSM exemple à tous les acteurs, et dans le même temps, tell de la FSM sur les opérations effectuées sur les données de sorte que la machine de l'etat va dans le bon état?

Voici la partie pertinente de l'état de la machine:

when(QUEUED, matchEvent(requestAccepted.class, MyApp.class,
    (requestAccepted, service) -> 
    goTo(PROCESSING).replying(PROCESSING)));

when(PROCESSING, matchEvent(completed.class, MyApp.class,
    (completed, service) -> goTo(DONE).replying(DONE)));

// During transitions, save states in the database.
onTransition(matchState(PROCESSING, DONE, () -> {
  nextStateData().setServiceStatus(DONE);
  databaseWriter.tell(nextStateData(), getSelf());

Et voici un exemple de l'un des acteurs du traitement de la demande:

ProcessingActor extends AbstractActor {

    @Override
      public void onReceive(Object message) throws Throwable {
        if (message instanceof processApplication) {
         // process the app
         // Initialize FSM for the Application
         FSM myFSM = Props.create(MYFSM.class);
         myFSM.tell( new completed(processApplication.app)
    }

Est-ce la bonne méthode pour initialiser l'état de la machine et de l'utiliser? Ou si l'initialisation se passer dans le constructeur de l' ProcessingActor? Mais dans ce cas il n'y aurait pas une machine de l'etat par application (données).

Answer 1

Alors que la description d'états et de transitions est plutôt ambigu dans l'OP, le statut de l'élu de la mise en œuvre, de ses implications et ceux des solutions de rechange peuvent être abordés.

La mise en œuvre à portée de main peut compter comme un "acteur par la demande" approche, contrairement à ce que de plus en plus fréquemment peut-être, où l'état de la machine acteur tampons et les poignées de multiples demandes. Il sera présenté plus loin.

Dans sa forme actuelle, la mise en œuvre est la seule AbstractFSM par demande je connais, en fait, un autre FSM en aval, qui alors ne peut pas être appelé "par la demande" et probablement pu être évité. Il ressemble à peu près comme ceci:

L'acteur, conformément à la demande" qui semble d'abord être entré dans cette discussion, qui a donné augmenter à ce blog et un peu plus tard, à l'occasion, a réclamé le titre d' un motif. Il semble, en partie, elle a été motivée par la réplication de l'une des caractéristiques de la Pulvérisation cadre, une sorte de précurseur de l'Akka http.

Un autre débat sur ce, parvenus à un résultat peu concluant sur la question de savoir si, à préférer un acteur unique à plus d'un par demande, et présente de routage comme une 3ème alternative, parce qu'un routeur agit comme un équilibreur de charge, de toucher l' arrière de la pression de sujet.

L'approche la plus fréquemment présenté en combinaison avec d' AbstractFSM et de ses variétés, cependant, c'est un seul FSM acteur que les tampons les messages entrants en utilisant l' whenUnhandled méthode à les accumuler par défaut, peu importe l'état actuel (par exemple, Akka dans l'Action, le chapitre "des Machines à états Finis et les Agents" ou la Lightbend buncher exemple). Je ne suis pas en mesure de sauvegarder la demande avec une référence, mais il semble que AbstractFSM est plus pensé pour modèle les états d'un acteur qui traite de multiples demandes, plutôt que celui d'une demande qui passe par de multiples étapes. Liées à l'OP qui approche signifierait, qu' ProcessingActor lui-même pourrait s'étendre AbstractFSM.

public class ProcessingActor extends AbstractFSM<sample.so.State, RequestQueue> {
{
    startWith(Idle, new RequestQueue());

    when(Idle, /* matchEvent(EventType, DataType, Action) */
            matchEvent(
                    Request.class,
                    RequestQueue.class,
                    (request, queue) -> goTo(Processing).using(queue.push(request)));
    /* more state-matchers */

    whenUnhandled(
            matchEvent(
                    Request.class,
                    RequestQueue.class,
                    (request, qeue) -> stay().using(qeue.push(request)));

    initialize();
}

D'arriver à quelque chose comme ça pour la "demande"-partie, où les écritures de base de données ne sont pas représentés par des états plus, plutôt que de l'état d'entrée et de sortie d'actions. Notez que tous les whenUnhandled de la branche n'apparaît pas dans le schéma, car il n'est pas lié à un changement d'état.

Sans entrer trop dans le de pesée (vague) les exigences, les élus de la mise en œuvre, AbstractFSM semble être un assez maladroit de machines pour enregistrer une séquence de statut par requête à une base de données. La documentation de la version 2.4 de la Akka présente un état de la machine sans l'aide de AbstractFsm et discute de la possibilité de distinguer d'abord les événements, puis les états ou l'inverse. Dans l' AbstractFSM-DSL, vous êtes lié pour discerner les états avant les événements (et des données). On peut même affirmer avec une certaine justification à s'abstenir de akka FSM au total.

Plus léger approche pour construire FSM utilise devenir/unbecome, une belle présentation est ici, une AbstractFSM vs devenir/unbecome discussion peut être trouvé ici. Plus proche proximité visuelle des règles métier donne l'argument majeur en faveur de l'ancien.

La saisie la plus glissante terrain de juger de l'utilisation de AbstractFSM pour la tâche qui avait. Je pense que, certaines choses peuvent être dites, compte tenu de la lecture de ces exigences est d'environ ok.

Les états forment une chaîne linéaire, de sorte que les deux "AbstractFSM-par-requête" peut être remplacé par d'autres par la demande de structures:

• une seule chaîne d'acteurs, chacun d'eux représentant un état

• un seul acteur, l'envoi d'événements à lui-même, un type d'événement par étape ci-dessus, en émettant des messages de la base de données de l'écrivain à chaque point. Peut-être une énumération suffit bien.

L'appel de ces versions peut augmenter considérant ceci: depuis la mise en œuvre utilise (au moins) un FSM par la demande, la question se pose, comment la transition QUEUED->PROCESSING vient (ou discovery processing -> discovery done d'ailleurs), et ce qu' QUEUED se rapporte à un niveau technique. Les articles ne sont jamais dans une file d'attente, toujours dans un superbe acteur (d'autre part, une file d'ATTENTE de l'état serait plus évident dans un seul FSM approche qui utilise une file d'attente, mais alors l'état ne s'applique pas à l'acteur, mais à la question de l'acteur poignées). Il n'est pas évident, qui événement externe doit provoquer la transition. Akka FSM est destiné à décrire déterministe FSM (voir aussi ce, en donnant le même argument pour les raisons opposées), mais si cette transition n'est pas déclenchée par un événement externe, le FSM doit devenir non déterministe et de déclencher sa propre epsilon-transitions ~ transitions pas causées par n'importe quelle entrée. Plutôt une structure complexe, probablement mis en œuvre en quelque sorte comme ceci:

onTransition(
    matchState(Initial, Queued, () -> {                    
        getSelf().tell(new Epsilon(), getSelf());
    }));