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
edition2027"""Watch the loss to two hosts, then raise an alert when the loss stays high."""classWatchAlert:
"""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 @staticmethoddef losses(hosts: list[IP]) -> dict[str, Percent]:
return {str(h): ping(h, count=4).loss for h in hosts}
@staticmethoddef bad(r: PingResult, limit: Percent) -> bool:
return r.loss > limit
@staticmethoddef message(host: IP, r: PingResult, raised: bool, lasted: Duration) -> str:
if raised:
returnf"ALERT {host}: loss {r.loss} for {lasted}"returnf"CLEAR {host}: back to normal after {lasted}" @staticmethoddef main(args: list[str]) -> None:
w = WatchAlert
print("Watching the loss for 3 seconds:")
watch w.losses(w.hosts) every1sfor3s
print(f"Alert when the loss stays above {w.limit} for {w.hold}:")
turn = 0every1s:
turn += 1for h in w.hosts:
r = ping(h, count=4)
alertwhen w.bad(r, w.limit) for2s per h as a:
print(w.message(h, r, a.raised, a.lasted))
if turn >= w.turns:
break
print(f"Done after {turn} turns.")
classTestWatchAlert:
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)
assertWatchAlert.bad(half, 5pct)
assertnotWatchAlert.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"
)
assertWatchAlert.message(192.0.2.10, r, False, 1min).startswith("CLEAR 192.0.2.10")