223 lines
29 KiB
JSON
223 lines
29 KiB
JSON
[
|
||
{
|
||
"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<String, BlockingQueue<Message>> mailboxes = new ConcurrentHashMap<>();\n\nBlockingQueue<Message> mailbox(String name) {\n return mailboxes.computeIfAbsent(name, _ -> new LinkedBlockingQueue<>());\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' > 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 <from> <to>\nla colle\n<from>\n<to>\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 <from> <to>\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": "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}"
|
||
]
|
||
}
|
||
] |