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

address_plan

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
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)])


class TestAddressPlan:
    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/22
        assert got["b"] == 10.40.8.0/24
        assert AddressPlan.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})
        except ValueError as e:
            assert "no free /24" in str(e)
        else:
            raise AssertionError("a /24 was found in a block that has none free")