Aller au contenu

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

bogolang
EN

← Exemples

watch_alert

Surveille la perte vers deux hôtes, puis lève et efface une alerte avec alert when.

Ce programme montre watch et alert when. D'abord il surveille la perte de paquets vers deux hôtes pendant 3 secondes. Ensuite il leur envoie un ping chaque seconde dans un bloc every, et lève une alerte pour un hôte dont la perte reste au-dessus de 5 pour cent pendant 2 secondes. Une alerte levée disparaît une fois quand la perte redescend.

Exécutez-le depuis ce dossier, sur les réponses enregistrées dans saved :

bogo run --replay saved watch_alert.bogo
bogo test watch_alert.bogo

Avec --replay saved, aucun ping n'est envoyé. Un rejeu donne la même réponse à chaque ping d'un hôte, donc le deuxième hôte reste à 50 pour cent de perte : son alerte est levée et ne disparaît jamais. Les réponses enregistrées ont été écrites à la main, et les adresses sont des adresses de documentation.

Pour l'utiliser sur votre propre réseau, mettez vos hôtes dans hosts, et réglez limit et hold (une vraie alerte attend en général des minutes, pas des secondes). Retirez turns et son break pour tourner jusqu'à Ctrl+C. Sans --replay, le programme envoie vraiment des pings. À la place de print, une alerte peut publier vers un outil de discussion avec webhook.

watch_alert.bogo
edition 2027
"""Watch the loss to two hosts, then raise an alert when the loss stays high."""


class WatchAlert:
    """Pings two hosts each second. A host whose loss stays above the limit for the
    time given raises an alert once, and clears it once when the loss comes back down.
    """

    hosts = [192.0.2.10, 198.51.100.20]
    limit = 5pct  # loss above this is bad
    hold = 2s  # for this long before the alert is raised
    turns = 4  # the program stops after this many turns; remove it to run until Ctrl+C

    @staticmethod
    def losses(hosts: list[IP]) -> dict[str, Percent]:
        return {str(h): ping(h, count=4).loss for h in hosts}

    @staticmethod
    def bad(r: PingResult, limit: Percent) -> bool:
        return r.loss > limit

    @staticmethod
    def message(host: IP, r: PingResult, raised: bool, lasted: Duration) -> str:
        if raised:
            return f"ALERT {host}: loss {r.loss} for {lasted}"
        return f"CLEAR {host}: back to normal after {lasted}"

    @staticmethod
    def main(args: list[str]) -> None:
        w = WatchAlert
        print("Watching the loss for 3 seconds:")
        watch w.losses(w.hosts) every 1s for 3s

        print(f"Alert when the loss stays above {w.limit} for {w.hold}:")
        turn = 0
        every 1s:
            turn += 1
            for h in w.hosts:
                r = ping(h, count=4)
                alert when w.bad(r, w.limit) for 2s per h as a:
                    print(w.message(h, r, a.raised, a.lasted))
            if turn >= w.turns:
                break
        print(f"Done after {turn} turns.")


class TestWatchAlert:
    def test_bad_is_above_the_limit_only(self) -> None:
        half = PingResult(4, 2, 50pct, None, None, None)
        none = PingResult(4, 4, 0pct, 20ms, 21ms, 23ms)
        assert WatchAlert.bad(half, 5pct)
        assert not WatchAlert.bad(none, 5pct)

    def test_messages(self) -> None:
        r = PingResult(4, 2, 50pct, None, None, None)
        assert (
            WatchAlert.message(192.0.2.10, r, True, 3s)
            == "ALERT 192.0.2.10: loss 50pct for 3s"
        )
        assert WatchAlert.message(192.0.2.10, r, False, 1min).startswith("CLEAR 192.0.2.10")