Aller au contenu

La version 0.1.0 est une première version, à l'essai. Voir ce qui n'est pas prouvé →

bogolang
EN

← Documentation

Votre premier programme

De bogo new à une exécution, une vérification, un test et une exécution sur des réponses enregistrées.

Toutes les pages de documentation

Cette page vous mène d'un dossier vide à un projet qui s'exécute, passe la vérification et passe ses tests. La dernière étape exécute le programme sur des réponses enregistrées, donc il ne contacte aucun hôte.

Il vous faut un Bogolang installé (install.md). Chaque commande ici est tapée dans un terminal. Les chemins de dossier dans la sortie sont raccourcis en ... sur cette page.

1. Créer un projet

bogo new linkcheck
Made project linkcheck in ...\linkcheck
Next: cd linkcheck and bogo run main.bogo

Le projet est un dossier qui contient trois choses :

Nom Ce que c'est
bogo.toml Le fichier du projet : son nom, son édition, son moteur et les paquets qu'il ajoute
main.bogo Le programme
tests/ Le dossier des fichiers de test, vide pour l'instant

bogo.toml tel que bogo new l'écrit :

[project]
name = "linkcheck"
edition = "2027"
engine = "3.15"

[packages]

main.bogo tel que bogo new l'écrit :

Bogolang
edition 2027


class Main:
    @staticmethod
    def main(args: list[str]) -> None:
        greeting: str = "Hello from linkcheck"
        print(greeting)

Trois règles se voient déjà. La première ligne nomme l'édition. Tout le code se trouve dans une classe. Le programme commence dans main, une méthode statique de la classe qui porte le nom du fichier (main.bogo contient class Main). language.md donne la règle complète.

2. L'exécuter

cd linkcheck
bogo run main.bogo
Hello from linkcheck

bogo main.bogo est la forme courte de bogo run main.bogo. Avant chaque exécution, le fichier est vérifié. Un programme qui contient une erreur ne démarre pas.

La première exécution crée un dossier .bogo dans le projet. Il contient l'environnement du projet et le Python que Bogolang génère à partir de votre fichier. Ne le partagez pas et ne le mettez pas sous contrôle de version : bogo sync le refait.

3. Écrire un vrai programme

Remplacez main.bogo par ceci. Il envoie un ping à deux routeurs en même temps et donne un mot pour chacun.

Bogolang
edition 2027


class Main:
    """Says which routers answer, and how well."""

    routers: list[IP] = [192.0.2.1, 192.0.2.2]
    slow: Duration = 50ms

    @staticmethod
    def state(r: PingResult, slow: Duration) -> str:
        """One word for a ping result."""
        if not r.ok:
            return "DOWN"
        if r.avg is not None and r.avg > slow:
            return "SLOW"
        return "ok"

    @staticmethod
    def main(args: list[str]) -> None:
        results: list[PingResult] = ping_all(Main.routers, count=3)
        for r in results:
            print(f"{r.host}  {Main.state(r, Main.slow):5} {r}")

Ce qui est nouveau ici :

  • 192.0.2.1 est une adresse et 50ms est une durée. Elles sont écrites telles quelles, sans guillemets. types-and-units.md liste tous les littéraux de ce genre.
  • Chaque méthode donne le type de chaque entrée et de son résultat.
  • ping_all et PingResult sont des noms intégrés. Chaque programme les a sans import. reach.md les décrit, et bogo doc ping_all affiche l'entrée dans le terminal.

4. Le vérifier

bogo check
main.bogo: no errors

Dans un projet, bogo check sans fichier vérifie main.bogo et les autres fichiers .bogo du projet. Il n'exécute rien et ne contacte rien.

Une erreur est montrée avec son fichier, sa ligne et sa colonne, la ligne elle-même et, quand il y en a un, le moyen de la corriger. Ce fichier, link_check.bogo, ajoute un débit à un niveau de puissance :

```bogo skip edition 2027

class LinkCheck: @staticmethod def main(args: list[str]) -> None: speed = 20Mbps level = -18.5dBm total = speed + level print(total)


`bogo check link_check.bogo` dit :

link_check.bogo:9:25: error: cannot use + between Rate and Power total = speed + level ^^^^^


Le programme n'est pas exécuté. La même erreur en Python n'apparaîtrait que lorsque la ligne
s'exécute, si elle s'exécute un jour.

## 5. Le tester

Un fichier de test s'appelle `test_*.bogo` et se trouve dans le dossier `tests`. Un test est
une méthode dont le nom commence par `test_`, dans une classe dont le nom commence par `Test`.
Il ne prend que `self` et réussit quand il se termine sans erreur. Enregistrez ceci sous
`tests/test_main.bogo` :

```bogo skip
edition 2027
from main import Main


class TestState:
    def test_no_answer_is_down(self) -> None:
        r: PingResult = PingResult(3, 0, 100pct, None, None, None)
        assert Main.state(r, 50ms) == "DOWN"

    def test_slow(self) -> None:
        r: PingResult = PingResult(3, 3, 0pct, 70ms, 80ms, 90ms)
        assert Main.state(r, 50ms) == "SLOW"

    def test_fast(self) -> None:
        r: PingResult = PingResult(3, 3, 0pct, 1ms, 2ms, 3ms)
        assert Main.state(r, 50ms) == "ok"

PingResult(sent, received, loss, min, avg, max) construit un résultat à la main, donc le test n'a besoin d'aucun réseau.

bogo test
tests/test_main.bogo
  passed  TestState.test_no_answer_is_down
  passed  TestState.test_slow
  passed  TestState.test_fast
3 passed, 0 failed

Un test échoué montre la ligne et le message de son assert :

  FAILED  TestState.test_wrong_on_purpose
    tests/test_main.bogo:20: assert Main.state(r, 50ms) == "SLOW", "a fast host is not slow"
    AssertionError: a fast host is not slow
3 passed, 1 failed

bogo test -k slow n'exécute que les tests dont le nom affiché contient slow. Le code de sortie est 0 quand tous les tests réussissent et 1 sinon.

Un test ne contacte jamais rien. Une commande d'équipement, un ping ou un appel web dans un test répond depuis le dossier tests/replay, et une commande sans réponse enregistrée fait échouer ce test.

6. L'exécuter sur des réponses enregistrées

bogo run main.bogo enverrait maintenant de vrais pings. Pour essayer le programme sans réseau, donnez-lui des réponses enregistrées avec --replay FOLDER. Alors rien n'est contacté.

Une réponse enregistrée de ping est un petit fichier dans le dossier reach du dossier de rejeu, nommé d'après l'adresse. Créez le dossier saved/reach dans le projet et écrivez ces deux fichiers.

saved/reach/ping_192.0.2.1.txt, trois réponses :

{"sent": 3, "times_ms": [1.2, 1.4, 1.1], "reason": ""}

saved/reach/ping_192.0.2.2.txt, aucune réponse (null est un paquet perdu) :

{"sent": 3, "times_ms": [null, null, null], "reason": ""}

Puis :

bogo run --replay saved main.bogo
192.0.2.1  ok    3 sent, 3 received, 0% loss, min/avg/max 1.1ms/1.233ms/1.4ms, jitter 0.25ms
192.0.2.2  DOWN  3 sent, 0 received, 100% loss

Les options se placent avant le nom du fichier. Les mots après le nom du fichier vont au programme, dans args.

Vous n'avez pas à écrire les réponses enregistrées à la main. bogo run --save-replay saved main.bogo exécute le programme pour de vrai et garde chaque réponse dans saved, pour un --replay ultérieur. Cette exécution contacte bien les hôtes.

Ajoutez --record pour voir chaque commande que le programme a envoyée, avec son heure en heure locale et en UTC :

bogo run --replay saved --record main.bogo
device     command  start_local                start_utc                  seconds  ok     error
192.0.2.2  ping     2026-11-20T18:04:58+01:00  2026-11-20T17:04:58+00:00  0.00     False  no reply
192.0.2.1  ping     2026-11-20T18:04:58+01:00  2026-11-20T17:04:58+00:00  0.00     True

Pour aller plus loin

  • language.md : la règle des classes, les types, les nouvelles instructions.
  • tools.md : chaque commande et option de bogo.
  • devices.md : les sessions vers les équipements, en lecture seule par défaut.
  • ../examples : treize programmes, chacun avec des réponses enregistrées, prêts pour --replay. Le plus proche de cette page est ../examples/reach_hosts.