Version 0.1.0 sur Python 3.15
Un langage de programmation pour les ingénieurs réseaux et télécommunications.
Bogolang est un langage à part entière, construit sur Python 3. Il a ses propres littéraux, instructions, règles et outils. Il est fondé sur les classes, comme Java : tout le code se trouve dans une classe, et un programme commence dans main. Les adresses, les sous-réseaux, les interfaces et les unités sont de vrais types. Joindre des hôtes, lire des équipements, tester une liste d'accès ou préparer un bond radio sont des commandes intégrées. Un changement sur un équipement est refusé s'il n'a pas de retour arrière. Tous les paquets Python continuent de fonctionner.
- Fondé sur les classes
- Windows et Linux
- Sans droit d'administrateur
- Licence MIT
edition 2027
"""Is everything up? Ping a list of hosts at once, trace the path to one, scan a small network."""
class ReachHosts:
"""A morning reach check: a table of ping results, one trace and one scan."""
hosts: list[IP] = [192.0.2.1, 192.0.2.10, 198.51.100.7, 203.0.113.20]
far: IP = 203.0.113.20
lan: Net = 192.0.2.0/29
slow: Duration = 50ms
@staticmethod
def verdict(r: PingResult, slow: Duration) -> str:
"""One word for a ping result: DOWN, LOSS, SLOW or ok."""
if not r.ok:
return "DOWN"
if r.received < r.sent:
return "LOSS"
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(ReachHosts.hosts, count=3, timeout=1s)
rows: list[dict[str, object]] = []
for r in results:
rows.append(
{
"host": r.host,
"received": f"{r.received}/{r.sent}",
"loss": r.loss,
"avg": r.avg,
"jitter": r.jitter,
"state": ReachHosts.verdict(r, ReachHosts.slow),
}
)
table(rows)
print(f"\nPath to {ReachHosts.far}:")
for hop in trace(ReachHosts.far, max_hops=10, probes=2):
print(f" {hop}")
up: list[IP] = scan(ReachHosts.lan)
print(
f"\n{len(up)} addresses answer in {ReachHosts.lan}: {', '.join(str(ip) for ip in up)}"
)
$ bogo run --replay saved reach_hosts.bogo
host received loss avg jitter state ------------ -------- ------- -------- ------ ----- 192.0.2.1 3/3 0pct 1.233ms 0.25ms ok 192.0.2.10 2/3 33.3pct 2.35ms 0.5ms LOSS 198.51.100.7 0/3 100pct DOWN 203.0.113.20 3/3 0pct 61.767ms 4.1ms SLOW Path to 203.0.113.20: 1 192.0.2.1 1ms 0% loss 2 198.51.100.1 8.65ms 0% loss 3 * * 100% loss 4 198.51.100.65 40.95ms 0% loss 5 203.0.113.20 61.05ms 0% loss 3 addresses answer in 192.0.2.0/29: 192.0.2.1, 192.0.2.2, 192.0.2.5
edition 2027
"""Address plan for new sites, worked out from one block. No device is contacted."""
class AddressPlan:
"""Give each new site a user subnet and a link to the hub, check a few
subnets someone asked for, then show the space that is still free."""
block: Net = 10.40.0.0/16
in_use: list[Net] = [10.40.0.0/22, 10.40.8.0/24, 10.40.64.0/18]
links: Net = 10.40.255.0/24
# site name, and the prefix length its users need
sites: dict[str, int] = {
"north-depot": 22,
"south-depot": 23,
"river-office": 24,
"harbour": 24,
}
# subnets other teams asked for: are they free?
requests: list[Net] = [10.40.12.0/23, 10.40.70.0/24, 10.40.128.0/24]
@staticmethod
def plan(block: Net, used: list[Net], wanted: dict[str, int]) -> dict[str, Net]:
"""The next free subnet of the asked size for each site, in the order given."""
taken: list[Net] = list(used)
out: dict[str, Net] = {}
for site, prefix in wanted.items():
net: Net = next_free(block, prefix, taken)
taken.append(net)
out[site] = net
return out
@staticmethod
def clashes(asked: list[Net], used: list[Net]) -> list[tuple[Net, Net]]:
"""Each asked subnet that overlaps a used one, with the one it hits."""
return [(a, u) for a in asked for u in used if a.overlaps(u)]
@staticmethod
def main(args: list[str]) -> None:
a = AddressPlan
subnets: dict[str, Net] = a.plan(a.block, a.in_use, a.sites)
p2p: list[Net] = a.links.split(30)
rows: list[dict[str, object]] = []
for n, (site, net) in enumerate(subnets.items()):
rows.append(
{
"site": site,
"users": str(net),
"hosts": net.size - 2,
"gateway": str(next(net.hosts)),
"hub link": str(p2p[n]),
}
)
table(rows)
used: list[Net] = a.in_use + list(subnets.values()) + [a.links]
print()
for asked in a.requests:
hits: list[tuple[Net, Net]] = a.clashes([asked], used)
print(
f"{asked}: "
+ (f"no, it overlaps {hits[0][1]}" if hits else "free, it can be given")
)
print()
print(f"Free in {a.block}:")
table([{"subnet": str(f), "addresses": f.size} for f in free_nets(a.block, used)])
$ bogo run address_plan.bogo
site users hosts gateway hub link ------------ ------------- ----- ---------- --------------- north-depot 10.40.4.0/22 1022 10.40.4.1 10.40.255.0/30 south-depot 10.40.10.0/23 510 10.40.10.1 10.40.255.4/30 river-office 10.40.9.0/24 254 10.40.9.1 10.40.255.8/30 harbour 10.40.12.0/24 254 10.40.12.1 10.40.255.12/30 10.40.12.0/23: no, it overlaps 10.40.12.0/24 10.40.70.0/24: no, it overlaps 10.40.64.0/18 10.40.128.0/24: free, it can be given
edition 2027
"""The plan of one microwave hop: free-space loss, link budget, fade margin and rain."""
class RadioLink:
"""Checks one microwave hop against a target availability.
The rain rate and the latitude depend on where the hop is. The values below are
examples only: take the rain rate R0.01 for your site from the ITU-R P.837 maps or
from local records, and the latitude of your own hop.
"""
name = "site-a to site-b"
freq = 18GHz
distance = 12km
tx = 18dBm
antenna_a = 38dBi
antenna_b = 38dBi
feeder_loss = 2dB # waveguide and connectors, both ends together
sensitivity = -70dBm # receiver threshold of the chosen modulation
rain_rate = 42.0 # EXAMPLE: mm/h passed for 0.01 percent of the year
latitude = 45.0 # EXAMPLE: degrees, north or south
polarization = "vertical"
target = 99.99pct
@staticmethod
def budget(distance: Distance, freq: Frequency) -> Budget:
losses: list[Gain] = [fspl(distance, freq), RadioLink.feeder_loss]
gains: list[Gain] = [RadioLink.antenna_a, RadioLink.antenna_b]
return link_budget(RadioLink.tx, gains, losses, RadioLink.sensitivity)
@staticmethod
def verdict(availability: Percent, target: Percent) -> str:
if availability >= target:
return "meets the target"
return "misses the target"
@staticmethod
def downtime_minutes(availability: Percent) -> float:
"""Minutes of rain outage in an average year."""
return (100 - availability.value) / 100 * 365 * 24 * 60
@staticmethod
def main(args: list[str]) -> None:
r = RadioLink
b = r.budget(r.distance, r.freq)
fade = rain_fade(r.distance, r.freq, r.rain_rate, r.polarization)
print(f"Hop {r.name}: {r.distance} at {r.freq}, {r.polarization} polarization")
print(f" Free-space loss {fspl(r.distance, r.freq)}")
print(f" First Fresnel zone {fresnel(r.distance, r.freq)} radius at mid-hop")
print(f" Received level {b.rx}")
print(f" Fade margin {b.margin}")
print(f" Rain fade (0.01%) {fade} at {r.rain_rate} mm/h")
if not b.ok:
print(" The link does not close: no availability to compute.")
return
avail = rain_availability(
b.margin, r.distance, r.freq, r.rain_rate, r.polarization, latitude=r.latitude
)
minutes = r.downtime_minutes(avail)
print(f" Availability (rain) {avail}, about {minutes:.0f} min down a year")
print(f" Target {r.target}: the hop {r.verdict(avail, r.target)}")
$ bogo run radio_link.bogo
Hop site-a to site-b: 12km at 18GHz, vertical polarization Free-space loss 139.137dB First Fresnel zone 7.069m radius at mid-hop Received level -47.137dBm Fade margin 22.863dB Rain fade (0.01%) 23.855dB at 42.0 mm/h Availability (rain) 99.989pct, about 59 min down a year Target 99.99pct: the hop misses the target
edition 2027
"""Would the access list on the internet uplink let these flows in? Reads a saved configuration."""
class AclTest:
"""Ask the list OUTSIDE-IN about a few flows and print each answer with the line
that decided it. When the test cannot be sure, it says so and names the line."""
config_file: str = "edge-rt1.cfg"
list_name: str = "OUTSIDE-IN"
# name, source, destination, protocol, destination port (0 when there is none)
flows: list[tuple[str, IP, IP, str, int]] = [
("web", 203.0.113.50, 198.51.100.10, "tcp", 443),
("dns", 203.0.113.50, 198.51.100.20, "udp", 53),
("sip from a blocked range", 192.0.2.10, 198.51.100.30, "tcp", 5060),
("sip", 203.0.113.60, 198.51.100.30, "tcp", 5061),
("voice media", 203.0.113.60, 198.51.100.30, "udp", 16000),
("ntp", 203.0.113.60, 198.51.100.99, "udp", 123),
("ssh to the web server", 203.0.113.60, 198.51.100.10, "tcp", 22),
("ping the web server", 203.0.113.60, 198.51.100.10, "icmp", 0),
]
@staticmethod
def ask(rules: Acl, src: IP, dst: IP, protocol: str, port: int) -> tuple[str, str]:
"""The answer in one word, and the line that decided or the reason there is no answer."""
try:
v: Verdict = rules.permits(src, dst, port=port, protocol=protocol)
except AclError as e:
return "CANNOT SAY", str(e)
return ("permitted" if v else "denied"), (
f"line {v.number}: {v.line}" if v.number else v.line
)
@staticmethod
def main(args: list[str]) -> None:
cfg: Config = load_config(AclTest.config_file, platform="iosxe")
rules: Acl = acl(cfg, AclTest.list_name)
print(f"{rules.name} on {cfg.hostname}: {len(rules.lines)} lines")
rows: list[dict[str, str]] = []
for name, src, dst, protocol, port in AclTest.flows:
answer, why = AclTest.ask(rules, src, dst, protocol, port)
service: str = f"{protocol}/{port}" if port else protocol
rows.append(
{
"flow": name,
"from": str(src),
"to": str(dst),
"service": service,
"answer": answer,
"why": why,
}
)
table(rows)
$ bogo run acl_test.bogo
OUTSIDE-IN on edge-rt1: 8 lines flow from to service answer why ------------------------ ------------ ------------- --------- ---------- --------------------------------------------------------- web 203.0.113.50 198.51.100.10 tcp/443 permitted line 1: permit tcp any host 198.51.100.10 eq 443 dns 203.0.113.50 198.51.100.20 udp/53 permitted line 3: permit udp any host 198.51.100.20 eq domain sip from a blocked range 192.0.2.10 198.51.100.30 tcp/5060 denied line 4: deny ip 192.0.2.0 0.0.0.255 any log sip 203.0.113.60 198.51.100.30 tcp/5061 permitted line 5: permit tcp any host 198.51.100.30 range 5060 5061 voice media 203.0.113.60 198.51.100.30 udp/16000 permitted line 6: permit udp any host 198.51.100.30 range 10000 20000 ntp 203.0.113.60 198.51.100.99 udp/123 denied implicit deny ssh to the web server 203.0.113.60 198.51.100.10 tcp/22 CANNOT SAY The access-list test does not understand 'established' in this line: permit tcp any any established
Démarrer
D'un dossier vide à un programme qui tourne, se vérifie et réussit ses tests.
OuvrirTélécharger
Un installateur pour Windows, un pour Linux. Sans droit d'administrateur, sans internet.
OuvrirDocumentation
Le langage, toutes les commandes intégrées, et la référence de chaque nom.
OuvrirExemples
Treize programmes avec leurs réponses enregistrées. Ils tournent sans équipement et sans réseau.
OuvrirLa forme d'un programme
Fondé sur les classes, comme Java
Tous les programmes Bogolang ont la même forme. Un ingénieur peut donc ouvrir le fichier d'un collègue et savoir où regarder.
- Tout le code se trouve dans une classe
- Le haut d'un fichier ne contient que la ligne d'édition, des imports et des classes. Une fonction, une affectation ou une ligne isolée en haut du fichier est refusée avant que le programme ne tourne.
- Un programme commence dans main
- Le départ est la méthode statique main de la classe qui porte le nom du fichier : link_check.bogo commence dans la classe LinkCheck. Les mots tapés après le nom du fichier arrivent dans args.
- Les tests sont aussi des classes
- Un test est une méthode dont le nom commence par test_, dans une classe dont le nom commence par Test. Un programme peut porter ses propres tests, et bogo test les lance.
- Tout ce que Python offre pour les classes reste
- L'héritage, les décorateurs, @dataclass, Enum, Protocol, les propriétés et les méthodes de classe fonctionnent comme en Python.
edition 2027
"""Says which routers answer."""
class LinkCheck:
"""Pings each router twice."""
routers: list[IP] = [192.0.2.1, 192.0.2.2]
@staticmethod
def main(args: list[str]) -> None:
for r in LinkCheck.routers:
print(r, ping(r, count=2))
class TestLinkCheck:
def test_there_are_two_routers(self) -> None:
assert len(LinkCheck.routers) == 2
top.bogo:3:1: error: code must be inside a class
x = 1
^
Only imports and classes stand at the top of a file. Put this line in a method of a class.
Intégré
Le travail quotidien d'un ingénieur réseau, en commandes du langage
Pas de bibliothèque à chercher, pas de surcouche à écrire. Chaque carte ouvre la page qui l'explique.
Joignabilité
Ses propres ping, ping_all, trace, tcping et scan, avec la taille, « ne pas fragmenter » et le DSCP.
Équipements
Inventaires, sessions SSH en lecture seule, commandes show en tableaux, SNMP, sauvegardes, instantanés avant et après un travail.
Changements
Le bloc change : apply, rollback, verify. --dry montre ce qui serait envoyé et n'envoie rien.
Configurations
La configuration comme un objet, règles d'audit, différences, modèles.
Planification
Sous-réseaux libres, chevauchements, recherche de route, un test de liste d'accès qui ne devine jamais.
Télécoms
Bilans de liaison radio, pluie, affaiblissement de la fibre, Erlang, qualité de la voix, mesures optiques.
Sorties
Tableaux, Excel, graphiques, rapports Word et HTML, courriel.
Surveillance
watch, alert when, et des écouteurs pour syslog, les traps SNMP et NetFlow.
Autres systèmes
API web, Meraki, RESTCONF, la console série.
Essayer sans risque
--replay lance un programme sur des réponses enregistrées et ne se connecte à rien.
Sûr par règle
Prudent avec le réseau, car une erreur y coûte cher
- Lecture seule par défaut
- Les sessions sur les équipements sont en lecture seule, sauf si un bloc change dit autre chose.
- Pas de changement sans retour arrière
- Un bloc change sans retour arrière est refusé avant que le programme ne tourne.
- Pas d'identifiants dans un fichier
- Les identifiants sont gardés dans le magasin protégé du système, jamais dans un fichier.
- Essayez sans équipement
- --dry affiche chaque changement et n'envoie rien. --replay répond à partir des sorties enregistrées.
change on d:
apply:
vlan {vid}
name {name}
interface {trunk}
switchport trunk allowed vlan add {vid}
rollback:
interface {trunk}
switchport trunk allowed vlan remove {vid}
no vlan {vid}
verify:
name in show("vlan brief")
str(vid) in show(f"interfaces {trunk} trunk")
$ bogo run --dry --replay saved change_vlan.bogo
DRY RUN: change on core-sw1. Nothing is sent.
apply:
vlan 30
name CAMERAS
interface GigabitEthernet1/0/2
switchport trunk allowed vlan add 30
rollback:
interface GigabitEthernet1/0/2
switchport trunk allowed vlan remove 30
no vlan 30
core-sw1: VLAN 30 would be added, nothing was sent
access-sw3: VLAN 30 is already there, nothing to do
Le langage
Python en dessous, plus strict au-dessus
Si vous lisez Python, vous lisez Bogolang. Les règles qu'il ajoute arrêtent les erreurs avant qu'un paquet ne quitte le PC.
-
01
Des valeurs avec un type
192.0.2.1, 10.40.0.0/16, 50ms et 18GHz sont des valeurs avec un type. Comparer une durée avec un débit est une erreur.
-
02
Vérifié avant de tourner
Une erreur de type arrête le programme avant son départ, avec la ligne, la colonne et ce qu'il faut écrire.
-
03
Les éditions gardent les anciens programmes en marche
Une édition fixe le sens du langage. Un Bogolang plus récent fait tourner chaque édition plus ancienne avec le sens qu'elle avait.
-
04
Tous les paquets Python continuent de fonctionner
Le moteur Python 3.15 reste à l'intérieur. Les paquets Python s'importent tels quels.
- sortes de travaux intégrés
- 10
- pages de documentation
- 20
- programmes d'exemple
- 13
- systèmes : Windows et Linux
- 2
Exemples
Des programmes qui tournent sur n'importe quel PC
Chaque exemple vient avec ses réponses enregistrées. Il tourne donc sans équipement et sans réseau.
Envoie un ping à quatre hôtes à la fois avec ping_all, trace le chemin vers l'un d'eux et balaie un petit réseau.
Lire le programme $ bogo run acl_test.bogoDemande à une liste d'accès si des flux passeraient, avec la ligne qui a décidé. Il ne devine jamais.
Lire le programme $ bogo run radio_link.bogoPrépare un bond hertzien : affaiblissement en espace libre, zone de Fresnel, marge d'évanouissement, pluie et disponibilité.
Lire le programmeD'un dossier vide à un programme qui tourne
Installez Bogolang, puis suivez la page du premier programme. Sa dernière étape tourne sur des réponses enregistrées et ne contacte aucun hôte.