Files
ProcessControl/_book/fr/search.json
T
2026-10-16 09:05:43 +02:00

343 lines
45 KiB
JSON
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
[
{
"objectID": "index.html",
"href": "index.html",
"title": "Contrôle de processus",
"section": "",
"text": "À propos de ces notes\nCes notes suivent un petit programme à travers une longue série de reconstructions, de l’appel de méthode direct à une architecture événementielle sur MQTT. Chaque reconstruction laisse le programme faire exactement ce qu’il faisait avant, et change qui connaît qui.\nLe programme construit ne change jamais : vous tapez une ligne, elle revient décalée de 13 lettres.\nCe qui change, c’est tout ce qui l’entoure. Le même système est reconstruit encore et encore, et chaque reconstruction pose trois questions, dans cet ordre :\nUn résumé est ajouté ici chaque fois qu’une étape est terminée : le livre grandit donc au rythme du travail. Chaque résumé dit ce que l’étape a fait, ce qui a été observé à l’exécution, et ce qui a bougé sur le plan architectural — en général une connaissance qui a changé de mains.\nD’après le matériel de Reto Konig, Université de Fribourg.",
"crumbs": [
"[About these notes]{.en}[À propos de ces notes]{.fr}[Über diese Notizen]{.de}"
]
},
{
"objectID": "index.html#sec-diagrams",
"href": "index.html#sec-diagrams",
"title": "Contrôle de processus",
"section": "Comment lire les figures",
"text": "Comment lire les figures\nChaque figure existe une fois comme dessin et trois fois comme langue. Dans la version web, une figure qui porte un flux de messages possède une petite barre de lecture : Lancer fait parcourir toute la chaîne à un message, Un saut avance d’une seule étape, et Réinitialiser remet tout à zéro. Les boîtes s’allument au passage du message : on voit ainsi quel composant attend et lequel travaille.\nDans le PDF, et dans un navigateur sans JavaScript, la même image est là — simplement immobile. Rien dans ces notes ne dépend de l’animation.",
"crumbs": [
"[About these notes]{.en}[À propos de ces notes]{.fr}[Über diese Notizen]{.de}"
]
},
{
"objectID": "00-orientation.html",
"href": "00-orientation.html",
"title": "1  Étape 0 — De quoi il s’agit",
"section": "",
"text": "1.1 Les trois questions\nL’étape 0 ne contient aucun code. Elle énonce le sujet : non pas ROT13, mais l’architecture autour de lui. La fonctionnalité reste presque inchangée pendant 81 étapes, et c’est précisément ce qui rend visibles les changements alentour.\nDeux règles sont posées ici et valent jusqu’au bout :\nC’est pourquoi la construction ne commence ni par MQTT, ni par les abonnements dynamiques. Un système aux médiateurs délibérément maladroits est bâti d’abord, mis en service, et l’on demande seulement ensuite s’ils ont mérité leur place.\nLa seconde règle concerne le vocabulaire : Intent, Status/State et Event ne sont nommés qu’après avoir été utilisés. Ils apparaissent vers l’étape 42, pas avant.\nL’itinéraire prévu, dès l’étape 0 :\nLa formulation des trois questions compte, et il est facile de la remplacer par une version plus faible :\n« Connaître » n’est pas « communiquer » : deux composants peuvent échanger des messages toute la journée sans que l’un nomme l’autre. « Décider du câblage » n’est pas « relier » : la partie qui transmet les messages n’est pas forcément celle qui a choisi la route. Les deux distinctions deviennent concrètes plus tard — la première dès l’étape 1, la seconde dans la partie III.",
"crumbs": [
"<span class='chapter-number'>1</span>  <span class='chapter-title'>[Step 0 — What this is about]{.en}[Étape 0 — De quoi il s'agit]{.fr}[Schritt 0 — Worum es geht]{.de}</span>"
]
},
{
"objectID": "00-orientation.html#sec-three-questions",
"href": "00-orientation.html#sec-three-questions",
"title": "1  Étape 0 — De quoi il s’agit",
"section": "",
"text": "Telle qu’elle est posée ici\nUne version plus faible\n\n\n\n\nQui connaît qui ?\nqui communique avec qui\n\n\nQui possède quoi ?\nquelles données détient chaque partie\n\n\nQui décide du câblage ?\nquelle partie relie le tout",
"crumbs": [
"<span class='chapter-number'>1</span>  <span class='chapter-title'>[Step 0 — What this is about]{.en}[Étape 0 — De quoi il s'agit]{.fr}[Schritt 0 — Worum es geht]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html",
"href": "01-part-i-calls.html",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "",
"text": "2.1 Étape 1 — Au plus simple : appeler, point\nLes étapes 1 à 10 restent dans une seule JVM. Le système est construit trois fois : en appels directs, en trois capacités qui refusent de se connaître, puis en ces mêmes capacités reliées par des médiateurs. Rien n’est encore distribué, et c’est bien l’idée : la seule chose qui change est qui connaît qui.\nProceduralRot13.java est le système entier dans un seul fichier source compact : une boucle qui lit une ligne, et une instruction qui affiche le texte transformé.\nIO.readln() occupe sa propre ligne, mais rot13(text) n’est pas une étape distincte : il est appelé dans l’argument de IO.println. Ni rot13 ni IO.println ne sait quoi que ce soit de l’autre. Celui qui connaît les deux, c’est main(), qui les nomme et fixe leur ordre.\nCe que main() sait de rot13 : qu’il existe, comment l’invoquer (un simple nom, tous deux vivent dans la même classe générée implicitement), quel argument il prend, ce qu’il retourne, qu’il est disponible à l’instant, et que l’exécution continue après son retour. Il ne sait pas comment rot13 est implémenté — c’est la seule chose qu’il peut ignorer.\nLa garantie de disponibilité mérite d’être nommée, car elle disparaîtra plus tard : main() et rot13 sont deux méthodes d’une classe déjà chargée, appelées sur le même fil, dans le même processus. Rien n’a besoin d’être démarré d’abord, aucun message ne voyage, aucun auditeur n’a besoin d’être abonné.\nObservé : taper une ligne l’affiche transformée ; Ctrl+D termine le programme sans rien afficher, car IO.readln() retourne null et main() retourne.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-1",
"href": "01-part-i-calls.html#sec-step-1",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "",
"text": "void main() {\n while (true) {\n var text = IO.readln();\n\n if (text == null)\n return;\n\n IO.println(rot13(text));\n }\n}\n\n\n\n\n\n\n\n\n\n\nFigure 2.1: La version procédurale. Le câblage est écrit dans le code : main() nomme les trois parties et fixe leur ordre.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-2",
"href": "01-part-i-calls.html#sec-step-2",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.2 Étape 2 — Trois capacités égoïstes",
"text": "2.2 Étape 2 — Trois capacités égoïstes\nUn composant égoïste dit : je sais ce que je peux faire, quelles données j’accepte et quelles données je produis — et je préfère ne pas connaître le processus métier qui m’entoure. Concrètement, ConsoleIn ne doit pas contenir rot13(...), et ROT13 ne doit pas contenir consoleOut(...).\nSupprimer ces appels crée aussitôt un problème, qui se pose en question : si personne ne connaît personne, qui fait de cela un système ? Notez ce que la question ne dit pas : la connaissance n’a pas disparu, elle doit aller ailleurs. Il manque deux liaisons, pas une — ConsoleIn ↔︎ ROT13 et ROT13 ↔︎ ConsoleOut.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-3",
"href": "01-part-i-calls.html#sec-step-3",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.3 Étape 3 — Donner une boîte aux lettres à chaque capacité",
"text": "2.3 Étape 3 — Donner une boîte aux lettres à chaque capacité\nLe plus petit mécanisme pour les liaisons manquantes : un message et une file nommée.\nrecord Message(String type, String value) {}\n\nMap&lt;String, BlockingQueue&lt;Message&gt;&gt; mailboxes = new ConcurrentHashMap&lt;&gt;();\n\nBlockingQueue&lt;Message&gt; mailbox(String name) {\n return mailboxes.computeIfAbsent(name, _ -&gt; new LinkedBlockingQueue&lt;&gt;());\n}\nCe sont des boîtes aux lettres (mailboxes) et non des sujets (topics), et la distinction mérite qu’on y insiste : si deux lecteurs appellent take() sur la même boîte, ils sont en concurrence — chaque message va à un seul d’entre eux et n’est pas copié aux deux. Un topic, en Publish/Subscribe, remettrait à chaque abonné sa propre copie. Un lecteur par message suffit pour l’instant, et la limitation est conservée volontairement : c’est elle qui rendra visible plus tard ce que Publish/Subscribe apporte réellement.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-steps-4-6",
"href": "01-part-i-calls.html#sec-steps-4-6",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.4 Étapes 4–6 — Les trois capacités deviennent égoïstes",
"text": "2.4 Étapes 4–6 — Les trois capacités deviennent égoïstes\nChaque capacité ne touche plus que ses propres noms de boîtes :\n\n\n\nCapacité\nlit\nécrit\n\n\n\n\nConsoleIn\nle clavier\nconsoleIn.outbox\n\n\nROT13\nrot13.inbox\nrot13.outbox\n\n\nConsoleOut\nconsoleOut.inbox\nla console\n\n\n\nAucune capacité ne contient le nom d’une autre, et c’est exactement le résultat : trois capacités bien isolées qui ne font absolument rien ensemble. Rien ne déplace un message de consoleIn.outbox vers rot13.inbox, ni de rot13.outbox vers consoleOut.inbox.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-7",
"href": "01-part-i-calls.html#sec-step-7",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.5 Étape 7 — Entre le médiateur",
"text": "2.5 Étape 7 — Entre le médiateur\nLa colle la plus simple possible : une boucle qui retire d’une boîte et dépose dans une autre, sans rien savoir de ce qui la traverse.\nvoid mediate(String from, String to) {\n while (true)\n mailbox(to).put(mailbox(from).take());\n}\nmain() démarre cinq threads virtuels : les trois capacités, plus deux médiateurs dont les routes sont passées en arguments — consoleIn.outbox → rot13.inbox et rot13.outbox → consoleOut.inbox.\nObservé : Hello World en entrée, Uryyb Jbeyq en sortie, exactement comme à l’étape 1. Mais Ctrl+D ne termine plus le programme. Le thread de ConsoleIn retourne (il ne boucle pas), et les quatre autres threads restent bloqués dans take() sur des boîtes vides, sans consommer de CPU. Ce qui maintient réellement le processus en vie, c’est la dernière ligne de main(), Thread.currentThread().join() : le thread principal s’attend lui-même, ce qui ne peut jamais aboutir. Les threads virtuels sont des threads daemon : ces quatre threads en attente n’auraient donc pas maintenu la JVM en vie à eux seuls.\n\n\n\n\n\n\nFigure 2.2: La version médiatisée dans une seule JVM. Dans la version web, Lancer fait parcourir à un message les huit sauts.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-8",
"href": "01-part-i-calls.html#sec-step-8",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.6 Étape 8 — Redemander : qui connaît qui ?",
"text": "2.6 Étape 8 — Redemander : qui connaît qui ?\nConsoleIn connaît-il ROT13 ? Non. ROT13 connaît-il ConsoleIn ou ConsoleOut ? Non. La topologie a-t-elle disparu ? Non — elle se trouve dans les deux appels mediate(...) à l’intérieur de main().\nC’est le premier résultat majeur :\n\nLe découplage ne fait souvent pas disparaître la connaissance. Il la déplace là où elle appartient.\n\nLa capacité « ROT13 transforme du texte » appartient à ROT13. La topologie ConsoleIn → ROT13 → ConsoleOut appartient à la composition du système. Ce qui a changé depuis l’étape 1, ce n’est pas que le câblage a quitté main() — il y est toujours — mais qu’il n’est plus écrit à l’intérieur d’une capacité. C’est désormais une donnée : deux paires de noms de boîtes. Recâbler touche ces deux lignes et aucune capacité.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-9",
"href": "01-part-i-calls.html#sec-step-9",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.7 Étape 9 — Pourquoi des threads virtuels ?",
"text": "2.7 Étape 9 — Pourquoi des threads virtuels ?\nCinq boucles attendent désormais indéfiniment : le clavier, rot13.inbox, consoleOut.inbox et les sources des deux médiateurs. Les threads virtuels sont simplement le moyen Java peu coûteux de faire attendre cinq choses à la fois dans une seule JVM.\nC’est une commodité d’implémentation, pas une architecture. L’architecture — qui connaît qui, et où vit le câblage — réside dans les noms de boîtes, pas dans les threads. La preuve de cette séparation : la même architecture tournera en processus séparés à l’étape 11, sans aucun thread partagé entre les parties.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-step-10",
"href": "01-part-i-calls.html#sec-step-10",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.8 Étape 10 — Garder les services égoïstes",
"text": "2.8 Étape 10 — Garder les services égoïstes\nLe raccourci évident : le premier médiateur ne fait que recopier les messages tels quels, alors pourquoi ne pas le supprimer et laisser ROT13 faire take() directement sur consoleIn.outbox ?\nParce que ROT13 contiendrait alors le nom consoleIn.outbox, c’est-à-dire qu’il saurait que ConsoleIn existe et où il publie. La topologie entrerait dans ROT13, et ROT13 cesserait d’être une capacité égoïste. Le test qui rend cela concret : supposons que l’entrée vienne d’une nouvelle capacité FileIn publiant dans fileIn.outbox.\n\n\n\n\n\n\n\n\n\navec le médiateur\navec le raccourci\n\n\n\n\nce qui change\nun argument du médiateur\nrunRot13 lui-même\n\n\nqui est touché\naucune capacité\nROT13, dont le travail n’a pas changé\n\n\n\nLe prix mérite d’être dit clairement : ce design peut sembler indirect — voire un peu bizarre. Il existe une autre manière de garder les services égoïstes sans médiateur sur le chemin de chaque message ; elle viendra plus tard.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "01-part-i-calls.html#sec-part-i-result",
"href": "01-part-i-calls.html#sec-part-i-result",
"title": "2  Partie I — Commencer par ce que l’on connaît déjà",
"section": "2.9 Ce que la partie I a déplacé",
"text": "2.9 Ce que la partie I a déplacé\n\n\n\n\n\n\n\n\nétape\noù vit la topologie\nqui peut recâbler\n\n\n\n\nétape 1\ndans le code de la capacité (IO.println(rot13(text)))\ncelui qui édite ce code\n\n\nétapes 7–8\ndans main(), en paires de noms de boîtes\ncelui qui édite main()\n\n\n\nFonctionnalité : inchangée. Lignes de code : davantage. Parties qui se connaissent : aucune. C’est le compromis que tout ce qui suit continue de mettre à l’épreuve.",
"crumbs": [
"<span class='chapter-number'>2</span>  <span class='chapter-title'>[Part I — Start with what you already know]{.en}[Partie I — Commencer par ce que l'on connaît déjà]{.fr}[Teil I — Mit dem beginnen, was man schon kennt]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html",
"href": "02-part-ii-processes.html",
"title": "3  Partie II — Franchir la frontière de processus",
"section": "",
"text": "3.1 Étape 11 — Séparer les composants\nLes é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.\nTrois 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.\nTCP 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.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-steps-12-13",
"href": "02-part-ii-processes.html#sec-steps-12-13",
"title": "3  Partie II — Franchir la frontière de processus",
"section": "3.2 Étapes 12–13 — Un répertoire devient une boîte aux lettres",
"text": "3.2 Étapes 12–13 — Un répertoire devient une boîte aux lettres\nLa correspondance tient en une ligne :\ndirectory = mailbox file = message\npublish = create file receive = watch directory\nmessageBoard/\n├── consoleIn/outbox/\n├── rot13/inbox/\n├── rot13/outbox/\n└── consoleOut/inbox/\nLe record Message gagne un horodatage optionnel, et le format de fichier reste deux lignes plus une troisième facultative :\nTEXT\nHello World\nTIMESTAMP: 2026-09-22T10:42:12.123Z\nUn 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.\nJackson 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.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-step-14",
"href": "02-part-ii-processes.html#sec-step-14",
"title": "3  Partie II — Franchir la frontière de processus",
"section": "3.3 Étape 14 — Le premier problème de système distribué : la publication",
"text": "3.3 Étape 14 — Le premier problème de système distribué : la publication\nUn 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 :\n\ncréer un fichier temporaire privé ;\nécrire le message complet ;\nle fermer ;\nle renommer atomiquement vers son nom final .msg ;\nles consommateurs ne réagissent qu’aux fichiers finaux.\n\nFiles.writeString(temporary, content);\nFiles.move(temporary, published, StandardCopyOption.ATOMIC_MOVE);\nLes 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.\n\nÉcrire et publier ne sont pas la même opération.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-step-15",
"href": "02-part-ii-processes.html#sec-step-15",
"title": "3  Partie II — Franchir la frontière de processus",
"section": "3.4 Étape 15 — Observer une boîte avec WatchService",
"text": "3.4 Étape 15 — Observer une boîte avec WatchService\nL’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.\nCela donne aussi un outil d’injection très rudimentaire. Avec ActuatorService lancé comme consommateur :\nprintf 'TEXT\\nHello from a file' &gt; messageBoard/consoleOut/inbox/manual.tmp\nmv messageBoard/consoleOut/inbox/manual.tmp messageBoard/consoleOut/inbox/manual.msg\nObservé : 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.\nLe 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.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-steps-16-17",
"href": "02-part-ii-processes.html#sec-steps-16-17",
"title": "3  Partie II — Franchir la frontière de processus",
"section": "3.5 Étapes 16–17 — Services et médiateur deviennent des processus",
"text": "3.5 Étapes 16–17 — Services et médiateur deviennent des processus\nLes trois capacités deviennent trois programmes, et le médiateur un quatrième type de programme :\n\n\n\n\n\n\n\n\n\nprogramme\njoue\nlit\nécrit\n\n\n\n\nSensorService.java\nConsoleIn\nle clavier\nconsoleIn/outbox\n\n\nProcessorService.java\nROT13\nrot13/inbox\nrot13/outbox\n\n\nActuatorService.java\nConsoleOut\nconsoleOut/inbox\nla console\n\n\nMediator.java &lt;from&gt; &lt;to&gt;\nla colle\n&lt;from&gt;\n&lt;to&gt;\n\n\n\nLe 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.\nConsé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.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-step-18",
"href": "02-part-ii-processes.html#sec-step-18",
"title": "3  Partie II — Franchir la frontière de processus",
"section": "3.6 Étape 18 — Exécuter la version entièrement externe, en local",
"text": "3.6 Étape 18 — Exécuter la version entièrement externe, en local\nCinq terminaux, cinq processus, un seul système de fichiers local entre eux :\njava SensorService.java # terminal 1\njava Mediator.java consoleIn/outbox rot13/inbox # terminal 2\njava ProcessorService.java # terminal 3\njava Mediator.java rot13/outbox consoleOut/inbox # terminal 4\njava ActuatorService.java # terminal 5\nObservé : 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.\nComptons : 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.\n\n\n\n\n\n\nFigure 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.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "02-part-ii-processes.html#sec-part-ii-result",
"href": "02-part-ii-processes.html#sec-part-ii-result",
"title": "3  Partie II — Franchir la frontière de processus",
"section": "3.7 Ce que la partie II a déplacé",
"text": "3.7 Ce que la partie II a déplacé\n\n\n\n\n\n\n\n\nétape\noù vit la topologie\nqui peut recâbler\n\n\n\n\nétape 1\ndans le code de la capacité\ncelui qui édite ce code\n\n\nétapes 7–8\ndans main(), en noms de boîtes\ncelui qui édite main()\n\n\nétape 18\ndans les deux lignes de commande Mediator.java &lt;from&gt; &lt;to&gt;\ncelui qui lance les processus\n\n\n\nLa 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.",
"crumbs": [
"<span class='chapter-number'>3</span>  <span class='chapter-title'>[Part II — Cross the process boundary]{.en}[Partie II — Franchir la frontière de processus]{.fr}[Teil II — Die Prozessgrenze überschreiten]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html",
"href": "03-part-iii-distributed.html",
"title": "4  Partie III — Le rendre réellement distribué",
"section": "",
"text": "4.1 Syncthing réplique ; il ne distribue pas\nCinq processus sur un seul ordinateur partagent encore un même système de fichiers. Les étapes 19 à 27 les répartissent sur deux machines, répliquent le tableau de messages entre elles avec Syncthing, mesurent ce que cela coûte, puis cassent délibérément un médiateur. À la fin, le prix des médiateurs est un chiffre, non une opinion.\nSyncthing maintient un répertoire répliqué entre plusieurs machines. C’est tout ce qu’on lui demande ici. Il ne sait rien d’Intent, de Status, d’Event, de ROT13 ni des médiateurs, et il n’a aucune notion de consommateur : pas d’abonnement, pas de sujet, aucune garantie de livraison, aucune idée que quelqu’un attend.\nLe déclencheur reste le nôtre. Chaque service exécute son propre WatchService sur un répertoire local ; Syncthing fait seulement apparaître les fichiers à cet endroit. C’est pourquoi aucun des trois services n’a changé d’une ligne lorsque le système est devenu distribué.\nDeux conséquences en découlent, et toutes deux apparaîtront comme des observations plutôt que comme des avertissements :",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-syncthing-not-a-broker",
"href": "03-part-iii-distributed.html#sec-syncthing-not-a-broker",
"title": "4  Partie III — Le rendre réellement distribué",
"section": "",
"text": "la réplication est asynchrone — le renommage .tmp → .msg est atomique sur chaque machine séparément, et rien ne promet d’ordre ni d’atomicité entre machines ;\nle système de fichiers est un transport sérieux, avec ses forces : les fichiers peuvent être gros, les répliques survivent à un redémarrage, et chaque message se lit avec cat.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-one-layer",
"href": "03-part-iii-distributed.html#sec-one-layer",
"title": "4  Partie III — Le rendre réellement distribué",
"section": "4.2 Tester une couche à la fois",
"text": "4.2 Tester une couche à la fois\nAvant que le moindre programme Java ne touche au dossier répliqué, le test le plus ennuyeux possible a été fait d’abord : écrire hello.txt sur une machine, vérifier qu’il apparaît sur l’autre, le supprimer, vérifier que la suppression revient. Les deux sens fonctionnent.\nCet ordre compte. Quand l’exécution distribuée a échoué plus tard, la question « est-ce la réplication ou mon programme ? » était déjà tranchée pour le transport, et la recherche pouvait commencer une couche plus haut.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-keystroke-cost",
"href": "03-part-iii-distributed.html#sec-keystroke-cost",
"title": "4  Partie III — Le rendre réellement distribué",
"section": "4.3 Ce que coûte une frappe",
"text": "4.3 Ce que coûte une frappe\nAvec le capteur sur une machine et les médiateurs, ROT13 et l’actionneur sur l’autre, une ligne tapée a produit quatre fichiers .msg, un par boîte :\n\n\n\nboîte\ncontenu\nhorodatage interne\n\n\n\n\nconsoleIn/outbox\nHello World\n23:02:05.315\n\n\nrot13/inbox\nHello World\n23:02:05.315\n\n\nrot13/outbox\nUryyb Jbeyq\n23:02:13.471\n\n\nconsoleOut/inbox\nUryyb Jbeyq\n23:02:13.471\n\n\n\nLes horodatages répétés prouvent que deux de ces quatre publications sont de pures copies : les médiateurs republient le message inchangé, horodatage compris. Ils calculent identity(x) = x, sous forme de processus distribués distincts.\nLe temps, mesuré sur les dates de modification des quatre fichiers d’une seule machine pour qu’aucun décalage d’horloge n’intervienne : le fichier du capteur apparaît à 01:02:05.432, les trois autres à 01:02:13.460, .504 et .532 — 8,10 s plus tard, et à 72 ms l’un de l’autre. Le travail propre de la chaîne a donc pris des millisecondes ; les huit secondes sont la propagation de Syncthing. La même chaîne, exécutée entièrement sur une machine, termine en 24 ms environ.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-break-a-mediator",
"href": "03-part-iii-distributed.html#sec-break-a-mediator",
"title": "4  Partie III — Le rendre réellement distribué",
"section": "4.4 Casser un médiateur",
"text": "4.4 Casser un médiateur\nArrêtez le premier médiateur et tapez deux lignes. ConsoleIn est vivant, ROT13 est vivant, ConsoleOut est vivant, Syncthing est vivant — et le flux métier est mort. Les deux lignes s’accumulent dans consoleIn/outbox ; rien ne va plus loin. Les médiateurs font partie de la chaîne de disponibilité.\nRedémarrez ensuite le médiateur. Rien n’est livré. FileMessageBoard.watch enregistre un répertoire pour ENTRY_CREATE et se bloque dans watcher.take() ; il ne liste jamais ce qui est déjà là. Les deux fichiers sont toujours sur le disque, dans les deux répliques : aucune donnée n’a été perdue. Ce qui n’a pas de mémoire, c’est l’abonnement.\nLa distinction mérite d’être retenue : les messages ont survécu, la livraison non. Un courtier répond à cela par l’état de session et les messages retenus ; dans notre propre code, ce serait une ligne — lister les fichiers .msg existants avant d’entrer dans la boucle d’observation — que le matériel se garde volontairement d’écrire pour l’instant.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-configurable-mediator",
"href": "03-part-iii-distributed.html#sec-configurable-mediator",
"title": "4  Partie III — Le rendre réellement distribué",
"section": "4.5 Le médiateur devient un service ordinaire",
"text": "4.5 Le médiateur devient un service ordinaire\nAvant de supprimer les médiateurs, une asymétrie disparaît : les services reçoivent leur travail sous forme de messages, alors que le médiateur recevait sa route en arguments de shell. On ne lui donne donc qu’un nom, ConfigurableMediator mediator1, dont il dérive une boîte de contrôle permanente, mediators/mediator1/inbox, et la route arrive comme message :\nROUTE\nconsoleIn/outbox\nrot13/inbox\nfrom et to voyagent dans un seul message, volontairement : en deux, le médiateur combinerait brièvement une nouvelle source avec l’ancienne destination et transmettrait au mauvais endroit. Une route est un seul fait, et un fait tient dans un message.\nUn orchestrateur éphémère publie les deux routes puis s’arrête : la topologie est visible en un seul endroit et n’est pas dans le chemin des données. Le lancer après les services, en ayant tapé une ligne avant, montre les deux moitiés d’un coup : la ligne précoce reste bloquée, la suivante circule.\nCe qui s’améliore : le médiateur a une identité, reçoit sa configuration par sa propre boîte, garde une capacité générique et tient sa topologie d’un orchestrateur. Ce qui ne s’améliore pas : le chemin des données. Il reste event → médiateur → copie de l'event, toujours un processus dans la chaîne de disponibilité, qui copie chaque message sans rien y ajouter. Et cette version accepte exactement une route : waitForRoute(...) retourne, puis le médiateur entre dans watch(route.from(), …) et ne lit plus jamais sa boîte de contrôle. Le recâblage à chaud n’est pas promis, car un watch bloquant ne peut pas servir à la fois une boîte de contrôle et une source — d’où l’aide à l’abonnement qui apparaît plus tard.",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "03-part-iii-distributed.html#sec-part-iii-result",
"href": "03-part-iii-distributed.html#sec-part-iii-result",
"title": "4  Partie III — Le rendre réellement distribué",
"section": "4.6 Ce que la partie III a déplacé",
"text": "4.6 Ce que la partie III a déplacé\n\n\n\n\n\n\n\n\nétape\noù vit la topologie\ndans le chemin des données ?\n\n\n\n\nétape 18\nles lignes de commande de l’opérateur\nles médiateurs y sont\n\n\nétape 27\nun orchestrateur, publiée comme Intent\nles médiateurs y sont encore\n\n\n\nLa question sur laquelle se referme la partie est donc précise et non rhétorique : pourquoi le service intéressé par la donnée ne pourrait-il pas l’écouter lui-même ?",
"crumbs": [
"<span class='chapter-number'>4</span>  <span class='chapter-title'>[Part III — Make it actually distributed]{.en}[Partie III — Le rendre réellement distribué]{.fr}[Teil III — Es wirklich verteilen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html",
"href": "04-part-iv-rewind.html",
"title": "5  Partie IV — Rembobinage",
"section": "",
"text": "5.1 Le raccourci évident, et son piège\nLes étapes 28 à 34 reviennent volontairement à une seule JVM. Sans délai de réplication ni cinq terminaux, la seule chose qui peut changer est qui connaît qui — l’idée s’essaie donc en quelques secondes plutôt qu’au cours d’une séance de débogage distribué.\nSi le premier médiateur ne fait que copier des messages, supprimons-le et laissons ROT13 lire la source lui-même :\nLe médiateur a disparu. Mais posons la question récurrente : ROT13 contient désormais le nom de la boîte de ConsoleIn. La topologie a quitté le médiateur pour entrer dans le service. Comme le dit le matériel : « nous avons supprimé le médiateur… et remis la topologie dans le service. Oups. »",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-the-trap",
"href": "04-part-iv-rewind.html#sec-the-trap",
"title": "5  Partie IV — Rembobinage",
"section": "",
"text": "listen(\"consoleIn.outbox\");",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-capability-vs-topology",
"href": "04-part-iv-rewind.html#sec-capability-vs-topology",
"title": "5  Partie IV — Rembobinage",
"section": "5.2 La capacité n’est pas la topologie",
"text": "5.2 La capacité n’est pas la topologie\nROT13 peut savoir deux choses : je sais transformer du texte et je suis capable d’écouter des messages texte compatibles. Il ne doit pas savoir mon entrée vient toujours de consoleIn.outbox — c’est de la topologie de déploiement.\nLe nom n’est donc pas compilé ; il arrive à l’exécution :\nTOPIC consoleIn.outbox\nROT13 apprend son câblage par la donnée. Notez qui l’envoie : dans DynamicQueueRot13.java, c’est main() qui publie les deux messages TOPIC — un configurateur, hors du chemin des données, dans le rôle qu’occupait l’orchestrateur. Ce ne peut pas être ConsoleIn : s’il disait à ROT13 à quoi s’abonner, il devrait savoir que ROT13 existe, et la topologie aurait seulement changé de capacité d’accueil.",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-dynamic-mechanics",
"href": "04-part-iv-rewind.html#sec-dynamic-mechanics",
"title": "5  Partie IV — Rembobinage",
"section": "5.3 Ce qui change dans le code",
"text": "5.3 Ce qui change dans le code\nlisten(...) n’a rien d’exotique : un thread virtuel qui appelle take() en boucle sur l’une des mêmes files. subscribe(...) démarre un tel thread par nom abonné. La conséquence se voit dans les boîtes :\n\nROT13 retire directement de consoleIn.outbox — le nom qu’on lui a transmis ;\nrot13.inbox n’est plus une boîte de charge utile. Elle porte des messages de contrôle, et la boucle de ROT13 la lit pour décider si un message est un TOPIC à appliquer.\n\nPlus rien n’écrit dans rot13.inbox pour déplacer des données. La boîte n’a pas disparu : elle a changé de métier, de la charge utile vers l’Intent.\nUne observation à l’exécution : après Ctrl+D, la sortie s’arrête mais le programme reste en vie. Rien n’a été interrompu — runConsoleIn retourne à la fin de l’entrée, donc le producteur a disparu, tandis que les deux threads abonnés restent bloqués dans take() sur des sources qui ne publieront plus. La JVM survit parce que main finit par Thread.currentThread().join(). « Le flux s’est arrêté » doit toujours être ramené à quel participant s’est arrêté.",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "04-part-iv-rewind.html#sec-route-topic-intent",
"href": "04-part-iv-rewind.html#sec-route-topic-intent",
"title": "5  Partie IV — Rembobinage",
"section": "5.4 ROUTE et TOPIC sont de l’Intent",
"text": "5.4 ROUTE et TOPIC sont de l’Intent\nAppliquons deux tests à TOPIC consoleIn.outbox. Décrit-il quelque chose qui est arrivé ? Non. Quelque chose actuellement vrai ? Non. Il dit commence à écouter ici — un comportement souhaité, donc de l’Intent. Le ROUTE du médiateur est du même genre : transmets d’ici à là.\nUn piège à nommer, car il est tentant dans une soutenance : publier un Intent est bien sûr quelque chose qui est arrivé. La classification suit ce que dit le message, pas le fait qu’il existe.\nEt une condition, qui reviendra : la version dynamique n’est pas automatiquement supérieure. Elle n’a de sens que si le consommateur comprend vraiment le contrat de message du producteur.\nMÉDIÉ STATIQUE DIRECT DYNAMIQUE\nProducteur → Médiateur → Consommateur Intent → (Producteur ──► Consommateur)",
"crumbs": [
"<span class='chapter-number'>5</span>  <span class='chapter-title'>[Part IV — Rewind]{.en}[Partie IV — Rembobinage]{.fr}[Teil IV — Zurückspulen]{.de}</span>"
]
},
{
"objectID": "glossary.html",
"href": "glossary.html",
"title": "Glossaire",
"section": "",
"text": "Chaque terme ci-dessous est défini là où il sert pour la première fois, et lié depuis chaque mention ultérieure. La flèche d’une entrée ramène à cet endroit.",
"crumbs": [
"Annexes",
"[Glossary]{.en}[Glossaire]{.fr}[Glossar]{.de}"
]
}
]