Donne à chaque nouveau site le prochain sous-réseau libre et une liaison vers le site central, puis affiche l'espace encore libre.
Donne à chaque nouveau site le prochain sous-réseau libre de la taille dont il a besoin, et une
liaison /30 vers le hub, à partir d'un seul bloc. Ensuite il vérifie quelques sous-réseaux que
d'autres équipes ont demandés, et affiche l'espace encore libre sous la forme du plus petit
nombre de sous-réseaux. Aucun équipement n'est contacté.
bogo run address_plan.bogo
bogo test address_plan.bogo
Pour l'utiliser sur votre propre réseau :
Mettez votre bloc dans block et les sous-réseaux déjà utilisés dans in_use.
Listez vos sites dans sites, chacun avec la longueur de préfixe dont ses utilisateurs ont
besoin.
Mettez le bloc des liaisons vers le hub dans links, et les sous-réseaux à vérifier dans
requests.
address_plan.bogo
edition2027"""Address plan for new sites, worked out from one block. No device is contacted."""classAddressPlan:
"""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]
@staticmethoddef 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
@staticmethoddef 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)]
@staticmethoddef 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)])
classTestAddressPlan:
def test_sites_do_not_overlap_what_is_used(self) -> None:
got: dict[str, Net] = AddressPlan.plan(10.40.0.0/16, [10.40.0.0/22], {"a": 22, "b": 24})
assert got["a"] == 10.40.4.0/22assert got["b"] == 10.40.8.0/24assertAddressPlan.clashes(list(got.values()), [10.40.0.0/22]) == []
def test_a_clash_names_the_subnet_it_hits(self) -> None:
hits: list[tuple[Net, Net]] = AddressPlan.clashes(
[10.40.9.0/24], [10.40.8.0/22, 10.40.12.0/24]
)
assert hits == [(10.40.9.0/24, 10.40.8.0/22)]
def test_a_full_block_is_refused(self) -> None:
try:
AddressPlan.plan(192.0.2.0/24, [192.0.2.0/25], {"big": 24})
exceptValueErroras e:
assert"no free /24"in str(e)
else:
raiseAssertionError("a /24 was found in a block that has none free")