Premiers pas

Cette séance ne demande rien d’autre que Signal Lab : tout va vers 127.0.0.1, cet ordinateur, si bien qu’aucun appareil, aucun réseau ni aucune règle de pare-feu n’entre en jeu. Vous allez :

1. envoyer un message OSC et le voir arriver ;
2. voir le même message dans l’Inspecteur ;
3. l’enregistrer dans la bibliothèque et le renvoyer de n’importe où ;
4. démarrer une API HTTP émulée et l’interroger ;
5. exécuter une expérience contre cette API, lire pourquoi elle échoue, la corriger et ajouter une vérification.

Si vous n’avez pas encore installé Signal Lab, voir Installation et mises à jour. Vous ne savez pas où se trouve quelque chose dans la fenêtre ? Voir La fenêtre.

Envoyer un message OSC et le voir arriver

D’abord, de quoi recevoir le message : le moniteur de l’écran OSC.

1. Ouvrez OSC dans la barre latérale.
2. Dans la partie Moniteur, réglez le champ Adresse d’écoute sur 127.0.0.1:9000, pour que le moniteur n’écoute que sur cet ordinateur.
3. Appuyez sur Écouter. Le bouton devient Arrêter, la console indique que le moniteur écoute, et le moniteur apparaît comme tâche dans le bandeau du panneau inférieur.

Maintenant le message, depuis la partie d’envoi juste à côté :

4. Dans la partie Envoi, laissez le champ Cible hôte:port à 127.0.0.1:9000, le port sur lequel le moniteur écoute.
5. Laissez le champ Adresse OSC à /hello/avatar/1 et l’unique argument flottant sous Arguments à 1.0 — ou saisissez une adresse et des valeurs de votre choix.
6. Appuyez sur Envoyer, ou sur Enter dans le champ de la cible ou de l’adresse.

Une ligne apparaît dans le tableau du moniteur : Heure d’arrivée, Source (127.0.0.1 et le port d’envoi), Adresse et Args. Sous la partie d’envoi, une ligne confirme ce qui a été envoyé et sa taille en octets ; renvoyez, et elle compte les répétitions.

Un avertissement concernant le pare-feu ?

Sous Windows, démarrer le moniteur peut faire apparaître sous l’en-tête un avertissement concernant le Pare-feu Windows. Il porte sur les messages venant d’autres machines ; le trafic sur 127.0.0.1 n’est jamais filtré. Appuyez pour l’instant sur Pas maintenant — L’avertissement du pare-feu explique quand autoriser.

Le voir dans l’Inspecteur

L’Inspecteur enregistre chaque trame que chaque outil envoie et reçoit — mais seulement tant que la capture est active.

1. Dans le panneau inférieur, ouvrez l’onglet Inspecteur.
2. Appuyez sur Armer la capture. Le point de l’onglet s’allume.
3. De retour dans la partie d’envoi, appuyez encore une fois sur Envoyer.

Deux lignes apparaissent, la plus récente en premier : le message tel qu’envoyé (→) et tel que le moniteur l’a reçu (←), chacune avec son protocole, l’adresse de l’autre extrémité, sa taille et un résumé. Cliquez sur l’une d’elles : le panneau Détail de la trame montre quel outil l’a envoyée ou reçue et sur quelles adresses, le message Décodé, et les Octets qui le composent.

Appuyez sur Désarmer la capture quand vous avez terminé ; tant que la capture est désarmée, elle ne coûte rien. Plus de détails dans Inspecteur.

L’enregistrer comme signal et le renvoyer

Un message dont vous aurez de nouveau besoin a sa place dans la bibliothèque de signaux.

1. Sur l’écran OSC, appuyez sur Enregistrer… sous la partie d’envoi.
2. Dans la fenêtre Enregistrer dans la bibliothèque, réglez le champ Nom sur First message et le champ Dossier sur Tutorial — un nouveau dossier est créé quand vous y enregistrez.
3. Appuyez sur Enregistrer.

La partie d’envoi est maintenant liée à ce signal : le bouton indique Enregistré, et une pastille à côté montre où se trouve le signal. Modifiez l’argument et la pastille signale la modification ; le bouton Enregistrer (Ctrl+S) mettrait à jour le signal.

Renvoyez-le maintenant, de trois façons :

• Depuis la bibliothèque. Cliquez sur la pastille : l’écran Signaux s’ouvre avec le signal sélectionné dans le dossier Tutorial (ou ouvrez Signaux et cliquez sur le signal). Appuyez sur Envoyer, ou sur Ctrl+Enter ; un double-clic dessus dans la liste l’envoie aussi.
• De n’importe où. Sur n’importe quel écran, appuyez sur Ctrl+K, tapez first et appuyez sur Enter.
• Depuis une expérience. Quand vous ajoutez un nœud, le menu liste vos signaux sous Signaux enregistrés, prêts à devenir une étape qui en envoie un.

À chaque fois, le moniteur montre le message qui arrive et la console nomme le signal. Un signal envoie exactement ce que son écran aurait envoyé. Plus de détails dans Signaux.

Quand vous en avez fini avec OSC, appuyez sur Arrêter sur le moniteur.

Interroger une API émulée

Signal Lab est livré avec cinq émulateurs, tous sur 127.0.0.1. L’un d’eux, API de démonstration, est une API HTTP sur 127.0.0.1:8080 avec ces routes :

Requête	Réponse
GET /health	200 avec {"status":"ok","time":"…"} — l’heure actuelle
GET /users/:id	200 avec l’utilisateur de cet identifiant, par exemple {"id":"42","name":"User 42"}
POST /users	201 avec un en-tête Location et le nouvel identifiant
GET /slow	200 au bout de 1,5 seconde
toute méthode, /flaky	503, 503, puis 200 à partir de la troisième requête
tout le reste	404

1. Ouvrez Émulateurs. La partie Bibliothèque liste les cinq ; sélectionnez API de démonstration.
2. Appuyez sur Démarrer. L’émulateur répond maintenant sur 127.0.0.1:8080 et tourne comme tâche.
3. Ouvrez HTTP. La méthode est GET ; réglez l’URL sur http://127.0.0.1:8080/health.
4. Appuyez sur Envoyer, ou sur Enter dans l’URL.

Sous Réponse, vous voyez Statut 200, Latence, Taille, les en-têtes de la réponse et le corps JSON. Envoyez http://127.0.0.1:8080/flaky trois fois : deux réponses 503, puis 200 — ce à quoi ressemble un service qui se rétablit pour un client qui réessaie.

De retour sur Émulateurs, le panneau En direct compte chaque requête, et la liste Reçus affiche chacune avec la Règle qui y a répondu et la Réponse. Laissez l’émulateur API de démonstration tourner pour la suite. Plus de détails dans Émulateurs.

Exécuter une expérience

Une expérience est un enchaînement d’étapes que vous pouvez exécuter encore et encore. Celle que Signal Lab ouvre la première fois — le modèle Vérification HTTP — envoie une requête à http://127.0.0.1:8080/ et vérifie que la réponse est 200.

Ouvrir le modèle

1. Ouvrez Expériences.
2. Si le canevas n’affiche pas quatre nœuds — Début, Requête HTTP, Statut HTTP, Fin —, appuyez sur ☰ à gauche de la barre d’outils (Expériences), choisissez Vérification HTTP dans la liste des modèles et appuyez sur Ouvrir une expérience. L’ouverture remplace l’expérience du canevas ; Ctrl+Z ramène la précédente.

Cliquez sur un nœud pour voir ses réglages dans le volet Propriétés, à droite. Les expériences s’enregistrent d’elles-mêmes pendant que vous les modifiez.

L’exécuter et lire pourquoi elle échoue

3. Appuyez sur Exécuter l’expérience.

La Chronologie de l’exécution s’ouvre sous le canevas, une ligne par étape quand elle démarre (En cours) et de nouveau quand elle se termine : l’heure, le nœud et le résultat. Cette exécution échoue :

• L’étape Début réussit et indique la graine de l’exécution.
• L’étape Requête HTTP réussit : la requête est partie et une réponse est revenue, HTTP 404.
• L’étape Statut HTTP échoue : elle attendait 200 et a reçu 404.

L’émulateur API de démonstration n’a pas de route pour / : il a donc répondu 404 — et la vérification l’a détecté. La ligne en haut de la chronologie indique Échoué et pourquoi. Cliquez sur une ligne pour sélectionner son nœud sur le canevas.

La requête elle-même a échoué ?

Si l’étape Requête HTTP échoue sur une connexion refusée, rien n’écoute sur 127.0.0.1:8080 : démarrez API de démonstration sur l’écran Émulateurs et relancez l’exécution.

Corriger la requête

4. Cliquez sur le nœud Requête HTTP.
5. Dans le volet Propriétés, réglez le champ URL sur http://127.0.0.1:8080/health.
6. Appuyez sur Exécuter l’expérience.

Cette fois, chaque étape réussit : Statut HTTP indique Condition remplie, Fin indique Terminé, et le titre de la chronologie indique Réussi.

Ajouter une vérification

Un statut 200 dit que le service a répondu ; il ne dit pas ce qu’il a répondu. Vérifiez aussi le corps :

7. Cliquez sur le nœud Statut HTTP.
8. Dans le volet Propriétés, appuyez sur Ajouter à la suite — ou appuyez sur A quand le canevas a le focus. Un menu de nœuds s’ouvre avec un champ de recherche.
9. Tapez assert_body et appuyez sur Enter. Un nœud Texte de la réponse est ajouté entre Statut HTTP et Fin, déjà relié, avec son champ Contient le texte prêt pour la saisie.
10. Tapez "status":"ok".
11. Appuyez sur Exécuter l’expérience.

La nouvelle étape réussit. Remplacez le texte par quelque chose que le corps ne contient pas et relancez pour la voir échouer en indiquant pourquoi.

Ce que laisse une exécution

• Un rapport. Quand une exécution se termine, Rapport enregistré apparaît dans le titre de la chronologie ; survolez-le pour voir le fichier. Une exécution qui se termine, réussie ou échouée, en écrit un dans le dossier runs de votre dossier de données, avec les valeurs qu’elle a utilisées et chaque étape. Dans un navigateur, c’est un lien de téléchargement.
• Une graine. Le titre affiche aussi la graine de l’exécution avec le bouton Épingler : les valeurs aléatoires d’une exécution suivent sa graine, et l’épingler les reproduit exactement.

Plus de détails dans Exécutions et rapports.

Ranger

Appuyez sur Tout arrêter dans l’en-tête : cela arrête l’émulateur API de démonstration et tout ce qui tourne encore. Votre signal, l’expérience et ses rapports restent dans votre dossier de données.

Et ensuite

• Concepts : les idées derrière les écrans, les signaux, les tâches, les émulateurs et les expériences.
• Expériences : l’éditeur en détail, et chaque type de nœud dans Nœuds.
• OSC, HTTP et les pages des autres protocoles, quand vous dirigerez Signal Lab vers de vrais équipements.
• La ligne de commande : exécuter la même expérience depuis un terminal ou un pipeline.