Flux d'exécution

1Présentation

Il est possible de demander l'exécution de plugins, avant et/ou après l'exécution des contrôleurs de l'application. Techniquement, les plugins sont des contrôleurs possédant des méthodes spéciales, qui peuvent modifier la requête avant de la transmettre au plugin suivant ou au contrôleur désigné. On peut chaîner des plugins avant le contrôleur, et d'autres plugins après.

Les fichiers source des plugins sont stockés dans le répertoire controllers de l'application.

Un même objet peut avoir à la fois des rôles de plugin et de contrôleur.

2Contrôle d'exécution

La chaîne d'exécution de Temma comporte 3 phases principales :

Les pré-plugins sont exécutés les uns après les autres.
Dans le contrôleur :
1. La méthode d'initialisation __wakeup() est exécutée.
2. L'action est exécutée. Cela peut être :
  - L'action proxy __invoke() si elle est définie.
  - L'action demandée en fonction de l'URL, si elle est définie.
  - L'action par défaut __call() si elle est définie.
3. La méthode de finalisation __sleep() est exécutée.
Les post-plugins sont exécutés les uns après les autres.

Chacune de ces méthodes peut agir sur le déroulement du flux d'exécution. Par défaut, si elles ne retournent rien (ou si elles retournent null ou self::EXEC_FORWARD, voir ci-dessous), l'exécution passe à l'étape suivante. Sinon, elles peuvent retourner des valeurs différentes, pour agir sur le flux d'exécution en revenant en arrière ou en sautant des étapes.

Voici un schéma récapitulatif, avec les différentes flux d'exécutions possibles :

2.1EXEC_FORWARD

Passe à la suite normale de la chaîne d'exécution.

La méthode doit retourner :

```
// pas de retour
```
```
return null;
```
```
return self::EXEC_FORWARD;
```

return \Temma\Web\Controller::EXEC_FORWARD;

Il est aussi possible de lever une exception (dans l'action ou dans une fonction appelée par elle) :

throw new \Temma\Exceptions\FlowForward();

2.2EXEC_STOP

Arrête l'exécution de la phase (pré-plugins, contrôleur ou post-plugins) en cours :

Par un pré-plugin : aucun autre pré-plugin ne sera exécuté et on passera directement à la phase du contrôleur.
Par la méthode d'initialisation du contrôleur : ni l'action ni la méthode de finalisation ne seront exécutées, et on passera directement à la phase des post-plugins.
Par l'action du contrôleur : la méthode de finalisation ne sera pas exécutée et on passera directement à la phase des post-plugins.
Par la méthode de finalisation du contrôleur : on passera à la phase des post-plugins (comme pour un EXEC_FORWARD).
Par un post-plugin : aucun autre post-plugin ne sera exécuté.

La méthode doit retourner :

```
return self::EXEC_STOP;
```

return \Temma\Web\Controller::EXEC_STOP;

Il est aussi possible de lever une exception (dans l'action ou dans une fonction appelée par elle) :

throw new \Temma\Exceptions\FlowStop();

2.3EXEC_HALT

Arrête toute la chaîne d'exécution et passe directement à la vue.

Par un pré-plugin : aucun autre pré-plugin ne sera exécuté, ni la phase du contrôleur, ni la phase post-plugin.
Par la méthode d'initialisation du contrôleur : ni l'action ni la méthode de finalisation ne seront exécutées, de même que la phase post-plugin.
Par l'action du contrôleur : la méthode de finalisation ne sera pas exécutée, de même que la phase post-plugin.
Par la méthode de finalisation du contrôleur : la phase post-plugin ne sera pas exécutée.
Par un post-plugin : aucun autre post-plugin ne sera exécuté.

La méthode doit retourner :

```
return self::EXEC_HALT;
```

return \Temma\Web\Controller::EXEC_HALT;

Il est aussi possible de lever une exception (dans l'action ou dans une fonction appelée par elle) :

throw new \Temma\Exceptions\FlowHalt();

2.4EXEC_RESTART

Relance le traitement de la phase (pré-plugins, contrôleur ou post-plugins) en cours.

Par un pré-plugin : toute la chaîne des pré-plugins va être exécutée de nouveau.
Par la méthode d'initialisation du contrôleur : La méthode d'initialisation va être exécutée de nouveau.
Par l'action du contrôleur : la méthode d'initialisation va être exécutée de nouveau.
Par la méthode de finalisation du contrôleur : la méthode d'initialisation va être exécutée de nouveau.
Par un post-plugin : toute la chaîne des post-plugins va être exécutée de nouveau.

La méthode doit retourner :

```
return self::EXEC_RESTART;
```

return \Temma\Web\Controller::EXEC_RESTART;

Il est aussi possible de lever une exception (dans l'action ou dans une fonction appelée par elle) :

throw new \Temma\Exceptions\FlowRestart();

2.5EXEC_REBOOT

Relance toute la chaîne de traitements (pré-plugins + contrôleur + post-plugins). Quel que soit l'endroit, l'exécution reprend au premier pré-plugin et redéroule l'exécution.

La méthode doit retourner :

```
return self::EXEC_REBOOT;
```

return \Temma\Web\Controller::EXEC_REBOOT;

Il est aussi possible de lever une exception (dans l'action ou dans une fonction appelée par elle) :

throw new \Temma\Exceptions\FlowReboot();

2.6EXEC_QUIT

Arrête l'exécution du framework. Depuis un plugin ou un contrôleur, cela interrompt l'ensemble des traitements ; ni les autres plugins, ni le contrôleur, ne seront exécutés. Contrairement à EXEC_HALT, la vue ne sera pas exécutée et les demandes de redirection ne sont pas prises en compte.

La méthode doit retourner :

```
return self::EXEC_QUIT;
```

return \Temma\Web\Controller::EXEC_QUIT;

Il est aussi possible de lever une exception (dans l'action ou dans une fonction appelée par elle) :

throw new \Temma\Exceptions\FlowQuit();