bytesim 0.1.0__py3-none-any.whl

bytesim/tui/commands/interpreter.py

@@ -0,0 +1,85 @@
+"""The command interpreter: tokens → handler. Shared by the app and the headless runner."""
+from __future__ import annotations
+
+from ...constants import REF
+from ...model import NetError
+from .base import CommandHost
+
+
+class Interpreter(CommandHost):
+    _commands: dict[str, str]
+
+    @staticmethod
+    def tokens(line: str) -> list[str]:
+        """Split on spaces, except inside parentheses: link1(rfab1, rfab2) is one token."""
+        out, cur, depth = [], "", 0
+        for ch in line:
+            depth += (ch == "(") - (ch == ")")
+            if ch.isspace() and depth <= 0:
+                if cur:
+                    out.append(cur)
+                cur, depth = "", 0
+            elif not (ch.isspace() and depth > 0):
+                cur += ch
+        if depth > 0:
+            raise NetError(f"unclosed parenthesis in {cur!r}")
+        return out + ([cur] if cur else [])
+
+    def dispatch(self, toks: list[str]) -> None:
+        """Route tokens to a handler. Shortcuts: ``r1`` selects, ``r1 s2`` cables,
+        a bare group name selects the group. ``key=value`` tokens become options."""
+        if not toks:
+            return
+        opts = {k.lower(): v.lower() for k, _, v in (t.partition("=") for t in toks if "=" in t)}
+        toks = [t for t in toks if "=" not in t]
+        if not toks:
+            raise NetError("missing command")
+        word, args = toks[0].lower(), toks[1:]
+
+        if REF.match(toks[0]):
+            if len(toks) == 1:
+                did, _ = self._ref(toks[0])
+                self.net.get(did)
+                self.canvas.select(did)
+                self.canvas.focus()
+                return
+            if len(toks) != 2:
+                raise NetError("to cable devices type two ids, e.g. r1 s2")
+            word, args = "link", toks
+        elif word not in self._commands and word in self.net.groups and not args:
+            word, args = "group", [word]
+
+        handler = self._commands.get(word)
+        if handler is None:
+            raise NetError(f"unknown command {word!r} — type help")
+        getattr(self, handler)(args, opts)
+
+    @staticmethod
+    def script_lines(text: str) -> list[tuple[int, str]]:
+        """(line number, command) for every non-blank line, with # comments removed."""
+        out = []
+        for n, raw in enumerate(text.splitlines(), 1):
+            line = raw.split("#", 1)[0].strip()
+            if line:
+                out.append((n, line))
+        return out
+
+    def run_script(self, text: str, origin: str = "script") -> int:
+        """Run a script's commands in order; stop at the first error, saying where.
+
+        While a script runs, the host may batch its usual per-command work (redraws,
+        re-addressing, DHCP animations) until the end. Returns how many commands ran."""
+        self.replaying += 1
+        ran = 0
+        try:
+            for n, line in self.script_lines(text):
+                try:
+                    self.dispatch(self.tokens(line))
+                except NetError as e:
+                    raise NetError(f"{origin}, line {n} ({line}): {e}") from None
+                ran += 1
+        finally:
+            self.replaying -= 1
+            if not self.replaying:
+                self.changed()
+        return ran

bytesim/tui/commands/naming.py

@@ -0,0 +1,68 @@
+"""Renumbering devices by BFS or DFS, once or automatically after every change."""
+from __future__ import annotations
+
+from ...model import Device, NetError
+from ...model.naming import ORDERS
+from .base import CommandHost
+from .registry import command
+
+
+class NamingCommands(CommandHost):
+    # (order, root device or None) while auto-renumbering is on. The root is held
+    # as a Device so it survives being renamed itself.
+    naming: tuple[str, Device | None] | None = None
+
+    @command("renumber", "rename")
+    def cmd_renumber(self, args: list[str], opts: dict[str, str]) -> None:
+        usage = "usage: renumber bfs|dfs [root]  ·  renumber auto bfs|dfs [root]  ·  renumber off"
+        if not args:
+            self.log_msg(f"auto-renumber: [b]{self.naming_text()}[/]  ({usage[7:]})")
+            return
+        words = [a.lower() for a in args]
+        if words == ["off"]:
+            self.naming = None
+            self.log_msg("auto-renumber off: ids stay as they are")
+            self.refresh_sidebar()
+            return
+        auto = words[0] == "auto"
+        if auto:
+            words, args = words[1:], args[1:]
+        if not words or words[0] not in ORDERS or len(words) > 2:
+            raise NetError(usage)
+        order = words[0]
+        root = self.net.get(self._ref(args[1])[0]) if len(args) == 2 else None
+        if auto:
+            self.naming = (order, root)
+            self.log_msg(f"auto-renumber on: [b]{self.naming_text()}[/] after every change")
+            self.changed()          # applies it now
+        else:
+            self._apply_renumber(order, root, announce_none=True)
+            self.changed()
+
+    def naming_text(self) -> str:
+        if self.naming is None:
+            return "off"
+        order, root = self.naming
+        alive = root is not None and root.id in self.net.devices and self.net.devices[root.id] is root
+        return f"{order.upper()} from {root.id if alive else self.net.default_root() or '—'}"
+
+    def auto_renumber(self) -> None:
+        """Called from changed(): keep ids in traversal order while the mode is on."""
+        if self.naming is not None:
+            order, root = self.naming
+            if root is not None and self.net.devices.get(root.id) is not root:
+                root = None          # the root was deleted: fall back to the default
+            self._apply_renumber(order, root, announce_none=False)
+
+    def _apply_renumber(self, order: str, root: Device | None, announce_none: bool) -> None:
+        c = self.canvas
+        mapping = self.net.renumber(order, root.id if root else None)
+        if c.selected in mapping:
+            c.selected = mapping[c.selected]
+        if mapping:
+            pairs = sorted(mapping.items(), key=lambda kv: (kv[1][0], int(kv[1][1:])))
+            shown = " ".join(f"{old}→{new}" for old, new in pairs[:12])
+            more = f" (+{len(pairs) - 12} more)" if len(pairs) > 12 else ""
+            self.log_msg(f"[cyan]renumbered ({order.upper()}):[/] {shown}{more}")
+        elif announce_none:
+            self.log_msg(f"already in {order.upper()} order: nothing to rename")

bytesim/tui/commands/registry.py

@@ -0,0 +1,28 @@
+"""A tiny command registry: decorate a handler with the words that invoke it."""
+from __future__ import annotations
+
+from typing import Callable
+
+Handler = Callable[..., None]
+
+
+def command(*names: str) -> Callable[[Handler], Handler]:
+    """Mark a method as the handler for one or more command words.
+
+    Handlers are called as ``handler(self, args, opts)`` where ``args`` are the
+    remaining tokens and ``opts`` holds any ``key=value`` tokens (lower-cased).
+    """
+    def mark(fn: Handler) -> Handler:
+        fn.__commands__ = names  # type: ignore[attr-defined]
+        return fn
+    return mark
+
+
+def collect(cls: type) -> dict[str, str]:
+    """Map every command word to the name of the method that handles it."""
+    table: dict[str, str] = {}
+    for klass in reversed(cls.__mro__):
+        for attr, fn in vars(klass).items():
+            for word in getattr(fn, "__commands__", ()):
+                table[word] = attr
+    return table

bytesim/tui/commands/scripting.py

@@ -0,0 +1,54 @@
+"""Construction scripts: export the network as console commands, and run script files."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.markup import escape
+
+from ...model import NetError
+from ...synthesis import MODES, synthesize
+from .base import CommandHost
+from .registry import command
+
+
+class ScriptCommands(CommandHost):
+    @command("run", "source")
+    def cmd_run(self, args: list[str], opts: dict[str, str]) -> None:
+        if len(args) != 1:
+            raise NetError("usage: run <file>   (one console command per line; # starts a comment)")
+        path = Path(args[0]).expanduser()
+        try:
+            text = path.read_text()
+        except OSError as e:
+            raise NetError(f"couldn't read {path}: {e}") from None
+        ran = self.run_script(text, origin=str(path))  # type: ignore[attr-defined]
+        self.log_msg(f"ran {ran} command{'s' if ran != 1 else ''} from {path}: "
+                     f"{len(self.net.devices)} devices, {len(self.net.links)} cables, {len(self.net.groups)} groups")
+
+    def export_script(self, args: list[str]) -> None:
+        """export script [explicit|readable|shortest] [file]"""
+        modes = [a for a in args if a.lower() in MODES]
+        files = [a for a in args if a.lower() not in MODES]
+        if len(modes) > 1 or len(files) > 1:
+            raise NetError(f"usage: export script [{'|'.join(MODES)}] [file]   (no file: show it here)")
+        mode = modes[0].lower() if modes else "readable"
+        res = synthesize(self.net, mode)
+        reuse = (f", reusing structure {len(res.used)} time{'s' if len(res.used) != 1 else ''} "
+                 f"({res.explicit_commands} without)" if res.used else "")
+        summary = f"{mode} script: {res.commands} commands{reuse}, verified by replaying it"
+        if files:
+            path = Path(files[0]).expanduser()
+            try:
+                path.write_text(res.script)
+            except OSError as e:
+                raise NetError(f"couldn't write {path}: {e}") from None
+            self.log_msg(f"[green]exported {summary} → {path}[/]")
+            self.log_msg(f"  [dim]replay it with: clear, then run {path}[/]")
+        else:
+            for line in res.script.splitlines():
+                self.log_msg(f"[dim]{escape(line)}[/]" if line.startswith("#") else escape(line))
+            self.log_msg(f"[green]{summary}[/]")
+        for s in res.used:
+            self.log_msg(f"  [cyan]{escape(s.command())}[/]  [dim]{escape(s.describe())}[/]")
+        for text in res.limitations:
+            self.log_msg(f"  [yellow]not expressible as a command: {escape(text)}[/]")

bytesim/tui/commands/switching.py

@@ -0,0 +1,192 @@
+"""Switching loops: broadcasts, spanning tree, and broadcast storms."""
+from __future__ import annotations
+
+from typing import Callable
+
+from ...model import NetError
+from ...model.stp import DEFAULT_PRIORITY, Flood
+from ..cables import route
+from .base import CommandHost
+from .registry import command
+
+ANIMATED_STORM_HOPS = 6      # how many generations of a storm to draw before it's declared
+
+
+class SwitchingCommands(CommandHost):
+    @command("broadcast", "bcast", "flood")
+    def cmd_broadcast(self, args: list[str], opts: dict[str, str]) -> None:
+        if len(args) != 1:
+            raise NetError("usage: broadcast <id[:port]>   (one frame to ff:ff:ff:ff:ff:ff)")
+        nic = self._sending_port(args[0])
+        name = self._ifname(nic)  # type: ignore[attr-defined]
+        net = self.net
+        mac = net.devices[nic[0]].mac(nic[1])
+        self._refuse_if_storming(nic, "broadcast")
+        fl = net.flood(nic)
+        if not fl.generations:
+            raise NetError(f"{name} can't send: its cable is down or blocked")
+        if fl.storm:
+            self.log_msg(f"[b gold1]BROADCAST[/] {name} [dim]{mac}[/] → everyone")
+            self.set_off_storm(fl, f"a broadcast from {name}")
+            return
+        net.learn_flood(fl)
+        hops, reached = len(fl.generations), sorted(fl.delivered)
+        self.log_msg(f"[b gold1]BROADCAST[/] {name} [dim]{mac}[/] → everyone: reached "
+                     f"{len(reached)} interface{'s' if len(reached) != 1 else ''} in {hops} hop"
+                     f"{'s' if hops != 1 else ''}, then the frames died out (no loop)")
+
+        def done() -> None:
+            for dev, _ in reached:
+                self.canvas.flash_device(dev, "gold1")
+            self.refresh_sidebar()
+
+        self.animate_flood(fl, "gold1", done)
+
+    @command("stp")
+    def cmd_stp(self, args: list[str], opts: dict[str, str]) -> None:
+        net = self.net
+        words = [a.lower() for a in args]
+        if not words:
+            self._stp_status()
+            return
+        if words[0] == "priority":
+            if len(args) != 3 or not args[2].isdigit():
+                raise NetError("usage: stp priority <switch> <0-65535>  (lower wins the root election)")
+            sw = self._switch(args[1])
+            net.stp_priority[sw] = int(args[2])
+            if net.stp_priority[sw] == DEFAULT_PRIORITY:
+                del net.stp_priority[sw]
+            self.log_msg(f"{sw}: bridge priority {args[2]}")
+            self.changed()
+            return
+        if words[-1] not in ("on", "off"):
+            raise NetError("usage: stp  ·  stp on|off  ·  stp <switch…> on|off  ·  stp priority <switch> <n>")
+        switches = ([self._switch(a) for a in args[:-1]] if len(args) > 1
+                    else [d.id for d in net.sorted_devices() if d.kind == "s"])
+        if words[-1] == "on":
+            net.stp_off -= set(switches)
+        else:
+            net.stp_off |= set(switches)
+        self.log_msg(f"STP {words[-1]} for {' '.join(switches) if len(args) > 1 else 'every switch'}")
+        self.changed()
+
+    # ---- storms -----------------------------------------------------------
+    def set_off_storm(self, fl: Flood, cause: str) -> None:
+        """A broadcast hit a live loop: mark the storm, explain it, and draw it."""
+        net = self.net
+        before = set(net.storming)
+        net.start_storm(fl)
+        totals = fl.totals
+        growth = (" → ".join(f"{n:,}" for n in totals[:7])
+                  + (f" → … → {totals[-1]:,}" if len(totals) > 7 else ""))
+        switches = " ".join(sorted(net.storming - before, key=net.bridge_id))
+        # A plain ring just circles; a meshier loop copies the frame faster than it dies.
+        multiplying = totals[-1] > 2 * max(totals[:4])
+        how = "multiplying as it goes" if multiplying else "copies circling in both directions"
+        self.log_msg(f"[b red]⚡ BROADCAST STORM[/] set off by {cause}: the frame goes round a switching "
+                     f"loop with no STP to block it, {how}")
+        self.log_msg(f"  [red]frames in flight per hop: {growth}, and it never stops "
+                     f"(layer-2 frames have no TTL)[/]")
+        mac = net.devices[fl.source[0]].mac(fl.source[1])
+        for sw, ports in sorted(fl.flaps.items(), key=lambda kv: net.bridge_id(kv[0])):
+            self.log_msg(f"  [orange1]MAC {mac} flapping on {sw}: "
+                         f"{'⇄'.join(f'p{p}' for p in sorted(ports))}[/]")
+        self.log_msg(f"  [red]{switches} saturated: nothing else gets through until the loop is broken "
+                     f"([b]stp on[/b], or fail/unlink a cable in it)[/]")
+        self.animate_flood(fl, "red", None, max_hops=ANIMATED_STORM_HOPS)
+        self.canvas.animate()
+        self.changed()
+
+    def storm_hint(self, *devs: str) -> str:
+        """' (broadcast storm on …)' if a storm is what's in the way, else ''."""
+        hit: set[str] = set()
+        for d in devs:
+            if d in self.net.devices:
+                hit |= self.net.storm_near(d)
+        if not hit:
+            return ""
+        return f" — broadcast storm on {' '.join(sorted(hit, key=self.net.bridge_id))} is saturating the links"
+
+    def _refuse_if_storming(self, nic: tuple[str, int], what: str) -> None:
+        if self.net.storm_near(nic[0]):
+            raise NetError(f"{what} from {self._ifname(nic)} can't get out"  # type: ignore[attr-defined]
+                           + self.storm_hint(nic[0]))
+
+    def animate_flood(self, fl: Flood, color: str, on_done: Callable[[], None] | None,
+                      max_hops: int | None = None) -> None:
+        """Draw a flood generation by generation: every copy of hop n, then hop n+1…"""
+        net, c = self.net, self.canvas
+        gens = fl.generations[:max_hops] if max_hops else fl.generations
+        links = {li for g in gens for li, _ in g}
+        c.heat(links)
+
+        def run(i: int) -> None:
+            if i >= len(gens):
+                c.cool(links)
+                if on_done:
+                    on_done()
+                return
+            moves = list(gens[i])
+            pending = [len(moves)]
+
+            def arrived() -> None:
+                pending[0] -= 1
+                if pending[0] == 0:
+                    run(i + 1)
+
+            hot = "red" if color == "red" or i >= 2 and fl.storm else color
+            for li, dev in moves:
+                l = net.links[li]
+                frm = l.other(dev)[0]
+                pts = route(net, l, li)
+                if l.a != frm:
+                    pts = pts[::-1]
+                df, dt = net.devices[frm], net.devices[dev]
+                cells = ([(df.port_x(l.port_of(frm)), df.y + 2)] + pts
+                         + [(dt.port_x(l.port_of(dev)), dt.y + 2)])
+                c.send_packet(cells, hot, arrived)
+
+        run(0)
+
+    # ---- helpers ------------------------------------------------------------
+    def _switch(self, tok: str) -> str:
+        did = self.net.get(self._ref(tok)[0]).id
+        if self.net.devices[did].kind != "s":
+            raise NetError(f"{did} isn't a switch: STP runs on switches")
+        return did
+
+    def _sending_port(self, tok: str) -> tuple[str, int]:
+        did, port = self._ref(tok)
+        dev = self.net.get(did)
+        if port is None:
+            port = next((p for p in range(1, dev.nports + 1) if self.net.link_index(did, p) is not None), None)
+            if port is None:
+                raise NetError(f"{did} has no cables")
+        elif self.net.link_index(did, port) is None:
+            raise NetError(f"{did}:{dev.port_name(port)} has no cable")
+        return dev.id, port
+
+    def _stp_status(self) -> None:
+        net = self.net
+        areas = [a for a in net._areas(net._trunks(honor_stp=False)) if len(a) > 1]
+        live = net.loop_links(honor_stp=True)
+        if not areas:
+            self.log_msg("[dim]no switch is cabled to another switch: nothing for STP to do[/]")
+        for area in areas:
+            order = sorted(area, key=net.bridge_id)
+            root = net.stp_roots.get(order[0])
+            off = [s for s in order if not net.stp_enabled(s)]
+            blocked = sorted((s, p) for s, p in net.stp_blocked if s in area)
+            loops = {i for i in live if net.links[i].a in area}
+            line = f"[b]{' '.join(order)}[/]: " + (f"root bridge [cyan]{root}[/]" if root else "[yellow]no STP switch[/]")
+            if off:
+                line += f" · STP off on {' '.join(off)}"
+            self.log_msg(line)
+            if blocked:
+                self.log_msg("  blocking " + " ".join(f"{s}:p{p}" for s, p in blocked))
+            if area & net.storming:
+                self.log_msg("  [b red]⚡ broadcast storm in progress[/]")
+            elif loops:
+                self.log_msg(f"  [red]live loop over {len(loops)} cables: the next broadcast here will storm[/]")
+            else:
+                self.log_msg("  [green]loop-free[/]")