3  Partie II — Franchir la frontière de processus

Les étapes 11 à 18 reprennent l’architecture de la partie I et la répartissent sur cinq processus du système d’exploitation, sur un seul ordinateur. Les capacités gardent leurs noms de boîtes ; seul le transport en dessous change, des objets Java vers des fichiers dans des répertoires. Le premier problème réellement distribué apparaît ici, et il n’a rien à voir avec ROT13.

3.1 Étape 11 — Séparer les composants

Trois processus ne peuvent pas partager une BlockingQueue : chaque commande java démarre sa propre JVM avec sa propre mémoire, la carte mailboxes existerait donc en trois exemplaires et chacun ne verrait que ses propres messages. Il faut un transport externe.

TCP conviendrait, MQTT conviendrait. C’est délibérément l’option la plus primitive qui est choisie, le système de fichiers, pour une raison en une ligne : parce qu’on peut le voir. Les messages deviennent des fichiers que l’on peut lister avec ls et lire avec cat pendant que le système tourne. Primitif ne veut pas dire inférieur : la partie VIII revient sur ce que le système de fichiers fait vraiment bien et vraiment mal.

3.2 Étapes 12–13 — Un répertoire devient une boîte aux lettres

La correspondance tient en une ligne :

directory = mailbox        file = message
publish   = create file    receive = watch directory
messageBoard/
├── consoleIn/outbox/
├── rot13/inbox/
├── rot13/outbox/
└── consoleOut/inbox/

Le record Message gagne un horodatage optionnel, et le format de fichier reste deux lignes plus une troisième facultative :

TEXT
Hello World
TIMESTAMP: 2026-09-22T10:42:12.123Z

Un message écrit à la main peut omettre l’horodatage. Le marqueur TIMESTAMP: empêche qu’une ligne de contenu ressemblant à une date soit prise pour une métadonnée ; dans ce format minuscule, une dernière ligne commençant par TIMESTAMP: est réservée.

Jackson pourrait être introduit ici et ne l’est volontairement pas. L’intérêt d’un format ridiculement simple, c’est que presque rien ne cache l’architecture — le message entier est lisible dans n’importe quel éditeur de texte, ce qui maintient l’attention sur qui parle à qui.

3.3 Étape 14 — Le premier problème de système distribué : la publication

Un lecteur qui surveille un répertoire peut découvrir un fichier avant que l’écrivain ait fini de l’écrire. D’où un protocole de publication :

  1. créer un fichier temporaire privé ;
  2. écrire le message complet ;
  3. le fermer ;
  4. le renommer atomiquement vers son nom final .msg ;
  5. les consommateurs ne réagissent qu’aux fichiers finaux.
Files.writeString(temporary, content);
Files.move(temporary, published, StandardCopyOption.ATOMIC_MOVE);

Les deux moitiés sont nécessaires. Le renommage est atomique — un lecteur voit soit aucun fichier .msg, soit le fichier complet — mais il ne protège rien si les lecteurs ramassent aussi les .tmp. .tmp et .msg restent dans le même répertoire, pour que le déplacement ne traverse pas de système de fichiers, où l’atomicité serait perdue.

Écrire et publier ne sont pas la même opération.

3.4 Étape 15 — Observer une boîte avec WatchService

L’observateur de système de fichiers de Java fournit la moitié consommateur : enregistrer un répertoire pour ENTRY_CREATE, se bloquer dans watcher.take(), et ignorer tout nom de fichier qui ne finit pas par .msg.

Cela donne aussi un outil d’injection très rudimentaire. Avec ActuatorService lancé comme consommateur :

printf 'TEXT\nHello from a file' > messageBoard/consoleOut/inbox/manual.tmp
mv messageBoard/consoleOut/inbox/manual.tmp messageBoard/consoleOut/inbox/manual.msg

Observé : rien ne se passe à l’apparition du fichier .tmp ; la ligne est affichée à l’instant où le renommage crée le nom .msg. Les deux formats acceptés fonctionnent, avec et sans horodatage final.

Le point architectural s’écrit producer → filesystem → consumer : le consommateur n’a pas pu distinguer un humain tapant mv d’un véritable service. Il connaît sa propre boîte d’entrée, pas qui y écrit. L’égoïsme a survécu à la frontière de processus.

3.5 Étapes 16–17 — Services et médiateur deviennent des processus

Les trois capacités deviennent trois programmes, et le médiateur un quatrième type de programme :

programme joue lit écrit
SensorService.java ConsoleIn le clavier consoleIn/outbox
ProcessorService.java ROT13 rot13/inbox rot13/outbox
ActuatorService.java ConsoleOut consoleOut/inbox la console
Mediator.java <from> <to> la colle <from> <to>

Le médiateur est générique : sa route n’est pas compilée en dur, elle arrive en deux arguments de démarrage. Mais une asymétrie mérite d’être gardée en tête : les trois capacités reçoivent leur travail sous forme de messages dans une boîte, tandis que le médiateur reçoit sa route comme configuration de démarrage, et il n’a ni nom ni boîte de contrôle propre où quelqu’un pourrait écrire.

Conséquence pratique : les arguments sont lus une seule fois, donc changer la route d’un médiateur en cours d’exécution exige de l’arrêter et de le relancer. Un fichier de configuration ne changerait rien — il est lui aussi lu au démarrage. Ce point reste volontairement ouvert jusqu’à ce que le coût des médiateurs distribués ait été ressenti.

3.6 Étape 18 — Exécuter la version entièrement externe, en local

Cinq terminaux, cinq processus, un seul système de fichiers local entre eux :

java SensorService.java                                 # terminal 1
java Mediator.java consoleIn/outbox rot13/inbox         # terminal 2
java ProcessorService.java                              # terminal 3
java Mediator.java rot13/outbox consoleOut/inbox        # terminal 4
java ActuatorService.java                               # terminal 5

Observé : Hello World tapé dans le terminal 1 est apparu comme Uryyb Jbeyq dans le terminal 5. Les trois terminaux du milieu n’ont rien affiché de nouveau — chaque médiateur affiche une ligne « Mediating: … » au démarrage, et ProcessorService n’affiche rien du tout. Ensuite, chacun des quatre répertoires de boîtes contenait un fichier .msg : la même ligne, recopiée le long de la chaîne.

Comptons : cinq processus pour ce que l’étape 1 faisait en une instruction. Ce n’est pas le moment d’optimiser : ce n’est pas encore censé être confortable.

Figure 3.1: Les cinq processus et les quatre répertoires de boîtes. Dans la version web, Lancer suit une ligne de texte du clavier à la console.

3.7 Ce que la partie II a déplacé

étape où vit la topologie qui peut recâbler
étape 1 dans le code de la capacité celui qui édite ce code
étapes 7–8 dans main(), en noms de boîtes celui qui édite main()
étape 18 dans les deux lignes de commande Mediator.java <from> <to> celui qui lance les processus

La topologie a maintenant quitté le code source : aucun fichier .java ne contient la route. Elle vit dans ce que l’opérateur a tapé, ce qui fait d’une personne l’orchestrateur actuel. Ce que la version à cinq processus apporte est réel — le câblage peut changer sans toucher aucun programme — et ce qu’elle coûte l’est tout autant : cinq processus, quatre copies de chaque message, et un programme qui ne s’arrête plus quand on appuie sur Ctrl+D.