pixie-lab 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

pixie/_partition.py

@@ -25,11 +25,41 @@ from __future__ import annotations
 import json
 import shutil
 import subprocess
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any
 
 _SECTOR_BYTES = 512
 
+# GPT partition type GUIDs (lowercase) that name a Linux root filesystem
+# across architectures. sfdisk reports GPT ``type`` as the type GUID.
+_LINUX_ROOT_GUIDS = frozenset(
+    {
+        "4f68bce3-e8cd-4db1-96e7-fbcaf984b709",  # root (x86-64)
+        "44479540-f297-41b2-9af7-d131d5f0458a",  # root (x86)
+        "b921b045-1df0-41c3-af44-4c6f280d3fae",  # root (arm64/aarch64)
+        "69dad710-2ce4-4e3c-b16c-21a1d49abed3",  # root (arm/32-bit)
+        "72ec70a6-cf74-40e6-bd49-4bda08e8f224",  # root (riscv64)
+    }
+)
+# Generic "Linux filesystem" data GUID (and the MBR type 0x83), used when
+# an image does not tag its root with an arch-specific root GUID.
+_LINUX_FS_TYPES = frozenset({"0fc63daf-8483-4772-8e79-3d69d8477de4", "83"})
+# Partition types that are never the root: firmware / boot-chain / swap.
+# Skipped in the last-resort "largest remaining" tier so a BIOS-boot stub
+# or the ESP is never mistaken for the root.
+_NON_ROOT_TYPES = frozenset(
+    {
+        "c12a7328-f81f-11d2-ba4b-00a0c93ec93b",  # EFI System
+        "21686148-6449-6e6f-744e-656564454649",  # BIOS boot
+        "0657fd6d-a4ab-43c4-84e5-0933c84b4f4f",  # Linux swap
+        "bc13c2ff-59e6-4262-a352-b275fd6f7172",  # XBOOTLDR (/boot)
+        "ef",  # MBR EFI System
+        "82",  # MBR Linux swap
+    }
+)
+
 
 class PartitionNotFound(RuntimeError):
     """Raised when a requested partition number is not present on
@@ -47,15 +77,13 @@ class PartitionInfo:
     size_bytes: int
 
 
-def partition_info(blob: Path, partition_number: int = 1) -> PartitionInfo:
-    """Return the byte range of ``partition_number`` on ``blob``.
-
-    Raises :class:`PartitionNotFound` if the blob is unpartitioned,
-    the specified partition is absent, or sfdisk fails to parse.
+def _sfdisk_partitions(blob: Path) -> list[dict[str, Any]]:
+    """Return sfdisk's partition list for ``blob`` (``node``/``start``/
+    ``size``/``type`` dicts). Raises :class:`PartitionNotFound` on a
+    missing blob, a missing / non-JSON sfdisk, or an unpartitioned image.
     """
     if not blob.is_file():
         raise PartitionNotFound(f"blob {blob!s} does not exist")
-
     try:
         result = subprocess.run(
             ["sfdisk", "--json", str(blob)],
@@ -69,14 +97,70 @@ def partition_info(blob: Path, partition_number: int = 1) -> PartitionInfo:
         raise PartitionNotFound(
             f"sfdisk --json exited rc={exc.returncode}: {exc.stderr.strip()}"
         ) from exc
-
     try:
         data = json.loads(result.stdout)
     except json.JSONDecodeError as exc:
         raise PartitionNotFound(f"sfdisk output was not JSON: {exc}") from exc
-
     table = data.get("partitiontable") or {}
-    parts = table.get("partitions") or []
+    return table.get("partitions") or []
+
+
+def _partition_number(node: str) -> int | None:
+    """Trailing partition index off an sfdisk ``node`` (``/dev/loop0p3``
+    -> 3, ``disk.img2`` -> 2). ``None`` when there is no trailing digit."""
+    i = len(node)
+    while i > 0 and node[i - 1].isdigit():
+        i -= 1
+    return int(node[i:]) if i < len(node) else None
+
+
+def root_partition_number(blob: Path) -> int:
+    """Pick the partition most likely to hold the Linux root filesystem.
+
+    nosi disk images do NOT agree on partition order: the ubuntu / debian
+    cloud images put root at p1 (ESP + BIOS-boot land at p13-15), while
+    arch / fedora put BIOS-boot + ESP first and root at p3. Hardcoding p1
+    extracts a 1 MiB BIOS-boot stub on the latter, which then fails to
+    mount at boot. Select by GPT type instead: an explicit Linux-root
+    type GUID wins; else the largest generic-Linux-filesystem partition;
+    else the largest partition that is not firmware / boot / swap.
+
+    Raises :class:`PartitionNotFound` if the table has no viable candidate.
+    """
+    parts = _sfdisk_partitions(blob)
+    cands = []
+    for entry in parts:
+        num = _partition_number(str(entry.get("node") or ""))
+        size = entry.get("size")
+        if num is None or size is None:
+            continue
+        cands.append((num, str(entry.get("type") or "").strip().lower(), int(size)))
+    if not cands:
+        raise PartitionNotFound(f"no partitions on {blob!s}")
+
+    tiers: tuple[Callable[[str], bool], ...] = (
+        lambda t: t in _LINUX_ROOT_GUIDS,
+        lambda t: t in _LINUX_FS_TYPES,
+        lambda t: t not in _NON_ROOT_TYPES,
+    )
+    for tier in tiers:
+        matched = [c for c in cands if tier(c[1])]
+        if matched:
+            # Largest matching partition wins the tier.
+            return max(matched, key=lambda c: c[2])[0]
+
+    raise PartitionNotFound(
+        f"no root-filesystem candidate among {len(cands)} partition(s) on {blob!s}"
+    )
+
+
+def partition_info(blob: Path, partition_number: int = 1) -> PartitionInfo:
+    """Return the byte range of ``partition_number`` on ``blob``.
+
+    Raises :class:`PartitionNotFound` if the blob is unpartitioned,
+    the specified partition is absent, or sfdisk fails to parse.
+    """
+    parts = _sfdisk_partitions(blob)
 
     # sfdisk names partitions as ``<blob_path><N>`` for MBR / GPT
     # alike; match by the trailing number after the shared prefix.

pixie/catalog/_fetcher.py

@@ -35,7 +35,11 @@ from pathlib import Path
 from typing import Any
 
 from pixie import oras
-from pixie._partition import PartitionNotFound, extract_partition
+from pixie._partition import (
+    PartitionNotFound,
+    extract_partition,
+    root_partition_number,
+)
 from pixie._util import CHUNK, now_iso
 from pixie.catalog._schema import CatalogEntry
 from pixie.catalog._store import CatalogStore
@@ -445,7 +449,12 @@ def _extract_rootfs_if_partitioned(
     blob_path: Path,
     progress: Callable[[dict[str, Any]], None] | None,
 ) -> None:
-    """Try to extract partition 1 into ``blobs/<sha>/rootfs.raw``.
+    """Extract the Linux root partition into ``blobs/<sha>/rootfs.raw``.
+
+    The root is selected by GPT type, not by a fixed partition number:
+    nosi images disagree on order (ubuntu/debian root=p1, arch/fedora
+    root=p3 behind BIOS-boot + ESP), so a hardcoded p1 would extract a
+    1 MiB BIOS-boot stub on the latter and fail to mount at boot.
 
     Silent on PartitionNotFound: the fetch still succeeds and the
     ephemeral / persist serve paths fall back to using the blob
@@ -458,7 +467,8 @@ def _extract_rootfs_if_partitioned(
     if progress is not None:
         progress({"phase": "extracting-rootfs"})
     try:
-        info = extract_partition(blob_path, rootfs, partition_number=1)
+        part_num = root_partition_number(blob_path)
+        info = extract_partition(blob_path, rootfs, partition_number=part_num)
     except PartitionNotFound as exc:
         _log.info(
             "fetch %r: skipping rootfs extract (%s); ephemeral / persist will serve the whole blob",
@@ -467,8 +477,9 @@ def _extract_rootfs_if_partitioned(
         )
         return
     _log.info(
-        "fetch %r: extracted partition 1 (%d bytes at offset %d) -> %s",
+        "fetch %r: extracted partition %d (%d bytes at offset %d) -> %s",
         entry.name,
+        part_num,
         info.size_bytes,
         info.start_bytes,
         rootfs,

pixie/catalog/catalog.toml

@@ -79,3 +79,27 @@ src = "oras://ghcr.io/safl/nosi/fedora-44-headless-netboot:latest"
 format = "tar.gz"
 arch = "x86_64"
 description = "Netboot bundle for fedora-44-headless: vmlinuz + initrd so pixie can nbdboot it over NBD."
+
+# pixie-live-env -- pixie's OWN image (not a nosi subset entry): the
+# nosi arch-headless base with the pixie CLI + pixie-on-tty1 service
+# injected. This is what the live-env boot modes (pixie-flash-once /
+# -always / pixie-inventory / pixie-tui) nbdboot ephemerally. Fetch it
+# from the Catalog tab, then set PIXIE_LIVE_ENV_IMAGE_SHA to the
+# content_sha256 pixie assigns after the fetch (the same sha the build
+# pipeline publishes as the pixie-live-env-x86_64.content-sha256 release
+# sidecar). Its netboot_src is arch-headless's own bundle: the transform
+# only touches userspace, so the kernel/initrd are reused unchanged.
+[[images]]
+name = "pixie-live-env"
+src = "https://github.com/safl/pixie/releases/latest/download/pixie-live-env-x86_64.img.gz"
+format = "img.gz"
+arch = "x86_64"
+description = "pixie live-env (nosi arch-headless + the pixie CLI + pixie-on-tty1 service). nbdbooted ephemerally for the live-env boot modes; set PIXIE_LIVE_ENV_IMAGE_SHA to its content_sha256."
+netboot_src = "oras://ghcr.io/safl/nosi/arch-headless-netboot:latest"
+
+[[images]]
+name = "nosi arch-headless netboot bundle"
+src = "oras://ghcr.io/safl/nosi/arch-headless-netboot:latest"
+format = "tar.gz"
+arch = "x86_64"
+description = "Netboot bundle for arch-headless: vmlinuz + initrd so pixie can nbdboot the pixie-live-env image over NBD."

pixie/machines/_routes.py

@@ -20,7 +20,7 @@ from pydantic import BaseModel, Field
 from pixie.events._kinds import MACHINE_BINDING_CHANGED, MACHINE_BOUND, MACHINE_DELETED
 from pixie.machines._store import (
     BOOT_MODES,
-    DEFAULT_BOOT_MODE,
+    UNCOMMITTED_BOOT_MODES,
     BadMac,
     MachinesStore,
     normalise_mac,
@@ -165,12 +165,14 @@ def upsert_machine(
         details: dict[str, Any] = {"boot_mode": row.boot_mode}
         if row.image_content_sha256:
             details["image_content_sha256"] = row.image_content_sha256
-        # ``machine.bound`` on a fresh MAC or on a row that was
-        # discovered-only (previous.boot_mode default with no bound
-        # image); ``machine.binding.changed`` when the mode or image
-        # actually shifted between the previous state and the new one.
+        # ``machine.bound`` on a fresh MAC or on a row that was only
+        # auto-registered (an uncommitted mode -- ipxe-exit or
+        # pixie-inventory -- with no bound image, including a machine
+        # that auto-inventoried then flipped back to ipxe-exit);
+        # ``machine.binding.changed`` when the mode or image actually
+        # shifted from a real prior operator bind.
         was_bound = previous is not None and (
-            bool(previous.image_content_sha256) or previous.boot_mode != DEFAULT_BOOT_MODE
+            bool(previous.image_content_sha256) or previous.boot_mode not in UNCOMMITTED_BOOT_MODES
         )
         changed = previous is not None and (
             previous.boot_mode != row.boot_mode

pixie/machines/_store.py

@@ -46,7 +46,24 @@ target boots into ``unavailable.j2``. Kept close to :data:`BOOT_MODES`
 so a reader adding a mode sees both spots at once."""
 
 BOOT_MODES: frozenset[str] = frozenset({"ipxe-exit", "nbdboot"}) | LIVE_ENV_MODES
-DEFAULT_BOOT_MODE = "ipxe-exit"
+
+# A freshly-discovered MAC auto-registers with this mode. Default is
+# ``pixie-inventory``: non-destructive (boots the live env, collects
+# lshw + disks, POSTs them back, reboots to firmware) and immediately
+# useful -- it populates the machine's inventory and unblocks the flash
+# modes, which require it. Inventory is one-shot: on the first inventory
+# POST the binding auto-flips to ``ipxe-exit`` (see pxe/_routes.py) so a
+# PXE-first machine doesn't re-inventory + boot-loop. Overridable per
+# deploy via ``PIXIE_DEFAULT_BOOT_MODE`` (resolved in web/main.py).
+# ``ipxe-exit`` degrades safely when no live env is staged: the renderer
+# falls back to an exit plan, so a bare deploy behaves like the old
+# default until the operator fetches the live env.
+DEFAULT_BOOT_MODE = "pixie-inventory"
+
+# The non-committal auto states: a machine sitting in one of these with
+# no bound image has not been meaningfully operator-bound yet. Used to
+# tell a first ``machine.bound`` from a later ``machine.binding.changed``.
+UNCOMMITTED_BOOT_MODES: frozenset[str] = frozenset({"ipxe-exit", "pixie-inventory"})
 
 # Presentation metadata for the six boot modes. Ordered
 # passthrough -> diagnostic -> interactive -> destructive so the
@@ -480,10 +497,18 @@ class MachinesStore:
             row = conn.execute("SELECT * FROM machines WHERE mac = ?", (canon,)).fetchone()
         return _row(row)
 
-    def touch_seen(self, mac: str, *, ip: str = "") -> Machine:
+    def touch_seen(
+        self, mac: str, *, ip: str = "", default_boot_mode: str = DEFAULT_BOOT_MODE
+    ) -> Machine:
         """Discovery-side write: create-or-update ``last_seen_at`` +
-        optionally ``last_seen_ip``. Does NOT touch operator fields."""
+        optionally ``last_seen_ip``. Does NOT touch operator fields.
+
+        A brand-new MAC is auto-registered with ``default_boot_mode``
+        (the deploy's ``PIXIE_DEFAULT_BOOT_MODE``, resolved by the
+        caller; falls back to :data:`DEFAULT_BOOT_MODE`). Unknown values
+        are refused here so a bad env can't seed an unrenderable mode."""
         canon = normalise_mac(mac)
+        mode = default_boot_mode if default_boot_mode in BOOT_MODES else DEFAULT_BOOT_MODE
         now = now_iso()
         with _DB_WRITE_LOCK, self._conn() as conn:
             existing = conn.execute("SELECT * FROM machines WHERE mac = ?", (canon,)).fetchone()
@@ -495,7 +520,7 @@ class MachinesStore:
                         discovered_at, last_seen_at, last_seen_ip, updated_at
                     ) VALUES (?, ?, '', ?, ?, ?, ?)
                     """,
-                    (canon, DEFAULT_BOOT_MODE, now, now, ip, now),
+                    (canon, mode, now, now, ip, now),
                 )
             else:
                 conn.execute(

pixie/oras_pull.py

@@ -0,0 +1,85 @@
+"""CLI: download a single ``oras://`` artifact blob to a file.
+
+Build pipelines -- the ``pixie-live-env`` image bake under ``cijoe/`` --
+need to pull a nosi base disk image the same way the operator UI's
+Fetch does, i.e. through :mod:`pixie.oras`. Those pipelines run under
+cijoe's own interpreter where ``import pixie`` is unavailable, so this
+module exposes the pull as a ``python -m pixie.oras_pull`` entry point.
+A build step then shells out to the repo's uv env::
+
+    uv run python -m pixie.oras_pull <oras-ref> <out-path>
+
+and reuses the exact resolve + streaming download the appliance uses,
+with no ``oras`` CLI dependency.
+
+Reuses :func:`pixie.oras.resolve_ref` (anonymous token -> manifest ->
+layer pick) and :func:`pixie.catalog._fetcher._stream_to_tmpfile` (the
+curl Range-resume download) so the downloaded bytes and their digest
+match a live Fetch byte-for-byte. The downloaded blob's sha256 is
+verified against the layer digest the registry resolved to; a mismatch
+is a hard error rather than a silently corrupt base image.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import sys
+from pathlib import Path
+
+from pixie.catalog._fetcher import FetchError, _stream_to_tmpfile
+from pixie.oras import OrasError, resolve_ref
+
+
+def pull(ref: str, out: Path) -> str:
+    """Resolve ``ref`` and download its blob to ``out`` atomically.
+
+    Returns the ``sha256:<hex>`` digest the registry resolved the
+    reference to (for a tag ref this is frozen at resolve time). Raises
+    :class:`pixie.oras.OrasError` on resolution failure,
+    :class:`pixie.catalog._fetcher.FetchError` on the download, and
+    :class:`ValueError` if the downloaded bytes do not hash to the
+    resolved digest.
+    """
+    resolved = resolve_ref(ref)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    # Stage into a scratch dir on the SAME filesystem as ``out`` so the
+    # final rename is atomic.
+    tmp_dir = out.parent / ".oras-pull-tmp"
+    tmp_path, sha256, _size = _stream_to_tmpfile(resolved.blob_url, resolved.headers, tmp_dir)
+
+    expected = resolved.digest.split(":", 1)[1] if ":" in resolved.digest else resolved.digest
+    if sha256 != expected:
+        tmp_path.unlink(missing_ok=True)
+        raise ValueError(
+            f"oras blob digest mismatch for {ref}: registry resolved "
+            f"{resolved.digest} but downloaded bytes hash to sha256:{sha256}"
+        )
+
+    tmp_path.replace(out)
+    # Best-effort scratch-dir cleanup; harmless if other files remain.
+    with contextlib.suppress(OSError):
+        tmp_dir.rmdir()
+    return resolved.digest
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="python -m pixie.oras_pull",
+        description="Download a single oras:// artifact blob to a file.",
+    )
+    parser.add_argument("ref", help="oras:// reference (tag or @sha256:<digest>)")
+    parser.add_argument("out", type=Path, help="output file path")
+    args = parser.parse_args(argv)
+
+    try:
+        digest = pull(args.ref, args.out)
+    except (OrasError, FetchError, ValueError, OSError) as exc:
+        print(f"pixie.oras_pull: {exc}", file=sys.stderr)
+        return 1
+    print(f"pulled {args.ref} -> {args.out} ({digest})")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

pixie/pxe/_renderer.py

@@ -90,6 +90,15 @@ class RenderContext:
     # Empty by default; the template shims it in unconditionally so
     # no-op is a legal value.
     extra_cmdline: str = ""
+    # Disk-image content sha the live-env boot modes boot over
+    # ephemeral nbdboot instead of the Debian live-boot squashfs.
+    # Operator-set via PIXIE_LIVE_ENV_IMAGE_SHA / the Live env page.
+    # Empty (default) keeps the squashfs path so existing deploys are
+    # untouched; when set, ``render`` streams this image over NBD for
+    # every LIVE_ENV_MODES machine (the machine's own bind still drives
+    # what GET /pxe/<mac>/plan returns, so the on-target CLI dispatches
+    # inventory / interactive / flash correctly).
+    live_env_image_sha: str = ""
 
 
 class PlanRenderer:
@@ -155,23 +164,7 @@ class PlanRenderer:
         if mode == "nbdboot":
             return self._render_nbdboot(machine, ctx, effective_extra)
         if mode in LIVE_ENV_MODES:
-            if not self._live_env_ready():
-                # netboot-pc bake artifacts have not been staged on
-                # this deploy yet; degrade to the readable
-                # unavailable plan so a bound target lands on a
-                # legible screen instead of a bty-media initrd.
-                return self._unavailable(
-                    machine,
-                    f"boot_mode={mode!r} needs pixie live-env media; "
-                    f"stage vmlinuz+initrd+squashfs under $PIXIE_LIVE_ENV_DIR",
-                )
-            return self._env.get_template("pixie-live-env.j2").render(
-                mac=machine.mac,
-                boot_mode=mode,
-                host=ctx.host,
-                port=ctx.port,
-                extra_cmdline=effective_extra,
-            )
+            return self._render_live_env(machine, ctx, mode, effective_extra)
         # Unknown mode: refuse loudly rather than falling through.
         return self._env.get_template("unavailable.j2").render(
             mac=machine.mac,
@@ -190,46 +183,10 @@ class PlanRenderer:
             return self._unavailable(
                 machine, "no image bound; set image_content_sha256 to a fetched entry"
             )
-
-        disk_entry = self._catalog_entry_by_sha(image_sha)
-        if disk_entry is None:
-            return self._unavailable(
-                machine,
-                f"no catalog entry with content_sha256={image_sha[:12]}; re-fetch it",
-            )
-        if not disk_entry.netboot_src:
-            return self._unavailable(
-                machine,
-                f"catalog entry {disk_entry.name!r} has no netboot_src; "
-                "advertise a sibling bundle before selecting nbdboot",
-            )
-        bundle_entry = self._catalog.get_entry_by_src(disk_entry.netboot_src)
-        if bundle_entry is None:
-            return self._unavailable(
-                machine,
-                f"netboot_src {disk_entry.netboot_src} has no catalog entry",
-            )
-        if not bundle_entry.content_sha256:
-            return self._unavailable(
-                machine,
-                f"netboot bundle {bundle_entry.name!r} not fetched yet",
-            )
-        artifact_dir = self._catalog.artifact_dir(bundle_entry.content_sha256)
-        if not (artifact_dir / "manifest.json").is_file():
-            return self._unavailable(
-                machine,
-                f"netboot bundle {bundle_entry.name!r} not unpacked "
-                f"(manifest.json missing under artifacts/{bundle_entry.content_sha256[:12]})",
-            )
-
-        # Blob for the disk image must exist too; that's what the NBD
-        # export streams over the wire.
-        blob = self._catalog.blob_path(image_sha)
-        if not blob.is_file():
-            return self._unavailable(
-                machine,
-                f"disk image {disk_entry.name!r} blob missing on disk; re-fetch it",
-            )
+        resolved = self._resolve_bundle_and_blob(image_sha)
+        if isinstance(resolved, str):
+            return self._unavailable(machine, resolved)
+        bundle_entry, blob = resolved
 
         # Persistent overlay path: if the machine's bind carries a
         # non-blank ``overlay_alias``, serve that alias's qcow2 via
@@ -299,7 +256,64 @@ class PlanRenderer:
             )
 
         # Ephemeral path: nbdkit's cow filter on the shared blob.
-        # Idempotent per name+blob.
+        # Idempotent per name+blob. Shared with the configured live-env
+        # image path (see :meth:`_render_live_env`).
+        return self._render_ephemeral_nbdboot(
+            machine, ctx, image_sha, bundle_entry, blob, extra_cmdline
+        )
+
+    def _resolve_bundle_and_blob(self, image_sha: str) -> tuple[CatalogEntry, Path] | str:
+        """Walk ``catalog[image_sha] -> netboot_src -> bundle`` and check
+        the bundle is unpacked + the disk-image blob is present on disk.
+
+        Returns ``(bundle_entry, blob_path)`` on success, or an
+        operator-readable reason string on the first missing link.
+        Shared by the machine-bound ``nbdboot`` mode and the configured
+        live-env image path so BOTH degrade to the same
+        ``unavailable`` reasons -- the live-env nbdboot is deliberately
+        the identical resolution the ``nbdboot`` mode uses, just against
+        a deploy-configured sha instead of the machine's bound one."""
+        disk_entry = self._catalog_entry_by_sha(image_sha)
+        if disk_entry is None:
+            return f"no catalog entry with content_sha256={image_sha[:12]}; re-fetch it"
+        if not disk_entry.netboot_src:
+            return (
+                f"catalog entry {disk_entry.name!r} has no netboot_src; "
+                "advertise a sibling bundle before selecting nbdboot"
+            )
+        bundle_entry = self._catalog.get_entry_by_src(disk_entry.netboot_src)
+        if bundle_entry is None:
+            return f"netboot_src {disk_entry.netboot_src} has no catalog entry"
+        if not bundle_entry.content_sha256:
+            return f"netboot bundle {bundle_entry.name!r} not fetched yet"
+        artifact_dir = self._catalog.artifact_dir(bundle_entry.content_sha256)
+        if not (artifact_dir / "manifest.json").is_file():
+            return (
+                f"netboot bundle {bundle_entry.name!r} not unpacked "
+                f"(manifest.json missing under artifacts/{bundle_entry.content_sha256[:12]})"
+            )
+        # Blob for the disk image must exist too; that's what the NBD
+        # export streams over the wire.
+        blob = self._catalog.blob_path(image_sha)
+        if not blob.is_file():
+            return f"disk image {disk_entry.name!r} blob missing on disk; re-fetch it"
+        return (bundle_entry, blob)
+
+    def _render_ephemeral_nbdboot(
+        self,
+        machine: Machine,
+        ctx: RenderContext,
+        image_sha: str,
+        bundle_entry: CatalogEntry,
+        blob: Path,
+        extra_cmdline: str,
+    ) -> str:
+        """Ensure an ephemeral nbdkit export for ``blob`` (idempotent per
+        name+blob) and render ``nbdboot.j2`` with ``persist=False`` -- an
+        overlay-on-tmpfs root, nothing persists across reboots. The
+        cmdline keeps ``pixie.server`` / ``pixie.mac`` (the template
+        always emits them) so an nbdboot'd live-env image's on-target
+        pixie CLI phones home to ``GET /pxe/<mac>/plan``."""
         export_name = _export_name_for(image_sha)
         try:
             port = self._ensure_export(export_name, image_sha, blob)
@@ -307,7 +321,6 @@ class PlanRenderer:
             return self._unavailable(
                 machine, f"nbdkit refused to start for export {export_name!r}: {exc}"
             )
-
         return self._env.get_template("nbdboot.j2").render(
             mac=machine.mac,
             host=ctx.host,
@@ -321,6 +334,61 @@ class PlanRenderer:
             persist=False,
         )
 
+    # ---------- live-env resolution --------------------------------
+
+    def _render_live_env(
+        self, machine: Machine, ctx: RenderContext, mode: str, extra_cmdline: str
+    ) -> str:
+        """Render a plan for one of the ``LIVE_ENV_MODES``.
+
+        Two deliveries, picked by ``ctx.live_env_image_sha``
+        (PIXIE_LIVE_ENV_IMAGE_SHA / the Live env page):
+
+        * Set -> boot that disk image over EPHEMERAL nbdboot, the same
+          code path the ``nbdboot`` mode uses. Proven on hardware to
+          bring the NIC up via dracut where the squashfs live-boot
+          hangs in the initramfs on some boards. If the configured
+          image or its netboot bundle isn't fetched, degrade to
+          ``unavailable`` (matching how ``nbdboot`` degrades) rather
+          than silently falling back -- a configured-but-broken live
+          env is an operator error worth surfacing.
+        * Unset -> the historical Debian live-boot squashfs
+          (``pixie-live-env.j2``), or ``unavailable`` when the
+          netboot-pc bake artifacts have not been staged.
+
+        Either way the machine's OWN ``boot_mode`` still drives what
+        ``GET /pxe/<mac>/plan`` returns, so the on-target pixie CLI
+        dispatches inventory / interactive / flash exactly as before."""
+        live_env_sha = ctx.live_env_image_sha
+        if live_env_sha:
+            resolved = self._resolve_bundle_and_blob(live_env_sha)
+            if isinstance(resolved, str):
+                return self._unavailable(
+                    machine,
+                    f"live-env image {live_env_sha[:12]} not bootable: {resolved}",
+                )
+            bundle_entry, blob = resolved
+            return self._render_ephemeral_nbdboot(
+                machine, ctx, live_env_sha, bundle_entry, blob, extra_cmdline
+            )
+        if not self._live_env_ready():
+            # netboot-pc bake artifacts have not been staged on this
+            # deploy yet; degrade to the readable unavailable plan so a
+            # bound target lands on a legible screen instead of a
+            # bty-media initrd.
+            return self._unavailable(
+                machine,
+                f"boot_mode={mode!r} needs pixie live-env media; "
+                f"stage vmlinuz+initrd+squashfs under $PIXIE_LIVE_ENV_DIR",
+            )
+        return self._env.get_template("pixie-live-env.j2").render(
+            mac=machine.mac,
+            boot_mode=mode,
+            host=ctx.host,
+            port=ctx.port,
+            extra_cmdline=extra_cmdline,
+        )
+
     def _unavailable(self, machine: Machine, reason: str) -> str:
         _log.info("pxe %s unavailable: %s", machine.mac, reason)
         slug = reason.split(";", 1)[0].replace(" ", "-").lower()[:60]

pixie/pxe/_routes.py

@@ -21,13 +21,14 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import PlainTextResponse
 
 from pixie.events._kinds import (
+    MACHINE_BINDING_CHANGED,
     MACHINE_DISCOVERED,
     MACHINE_INVENTORY_UPDATED,
     PXE_PLAN_RENDERED,
     PXE_PLAN_UNAVAILABLE,
     PXE_STATUS_RECEIVED,
 )
-from pixie.machines._store import BadMac, MachinesStore, normalise_mac
+from pixie.machines._store import DEFAULT_BOOT_MODE, BadMac, MachinesStore, normalise_mac
 from pixie.pxe._renderer import PlanRenderer, RenderContext
 
 _log = logging.getLogger(__name__)
@@ -79,10 +80,23 @@ def _render_context(request: Request) -> RenderContext:
     # (envvars-style pin) -> empty. Known-good values per hardware are
     # documented in docs/src/hardware-quirks.md.
     extra_cmdline = ""
+    # Disk-image content sha the live-env boot modes nbdboot ephemerally
+    # instead of fetching the Debian live-boot squashfs. Same resolution
+    # shape: /ui/live-env override (state.db) -> $PIXIE_LIVE_ENV_IMAGE_SHA
+    # -> empty (empty keeps the squashfs path). Proven on hardware; see
+    # the renderer's _render_live_env.
+    live_env_image_sha = ""
     settings = getattr(request.app.state, "settings_store", None)
     if settings is not None:
         extra_cmdline = settings.resolve_live_env_extra_cmdline()
-    return RenderContext(host=host, port=port, nbd_host=nbd_host, extra_cmdline=extra_cmdline)
+        live_env_image_sha = settings.resolve_live_env_image_sha()
+    return RenderContext(
+        host=host,
+        port=port,
+        nbd_host=nbd_host,
+        extra_cmdline=extra_cmdline,
+        live_env_image_sha=live_env_image_sha,
+    )
 
 
 @router.get("/pxe-bootstrap.ipxe", response_class=PlainTextResponse)
@@ -132,6 +146,33 @@ async def pxe_inventory(request: Request, mac: str) -> PlainTextResponse:
             summary=f"{canon} posted inventory",
             details=details,
         )
+
+    # Inventory is one-shot: once a machine has reported, flip a
+    # pixie-inventory binding to ipxe-exit so a PXE-first machine does
+    # not re-inventory and boot-loop. Mirrors pixie-flash-once's
+    # self-terminating flip (see pxe_status). Preserve the row's other
+    # fields; the collected inventory stays. Rebinding to
+    # pixie-inventory buys exactly one more pass.
+    row = machines.get(canon)
+    if row is not None and row.boot_mode == "pixie-inventory":
+        with contextlib.suppress(ValueError):
+            machines.upsert_binding(
+                canon,
+                boot_mode="ipxe-exit",
+                image_content_sha256=row.image_content_sha256,
+                labels=list(row.labels),
+                target_disk_serial=row.target_disk_serial,
+                extra_cmdline=row.extra_cmdline,
+                overlay_alias=row.overlay_alias,
+            )
+        if log is not None:
+            log.emit(
+                MACHINE_BINDING_CHANGED,
+                subject_kind="machine",
+                subject_id=canon,
+                summary=f"{canon}: inventory collected, auto-exit (pixie-inventory is one-shot)",
+                details={"boot_mode": "ipxe-exit", "reason": "inventory-once"},
+            )
     return PlainTextResponse("", status_code=204)
 
 
@@ -168,7 +209,8 @@ def pxe_plan(request: Request, mac: str) -> PlainTextResponse:
     # event fires exactly once (touch_seen itself can't emit -- stores
     # hold no EventsLog by design).
     is_new = machines.get(canon) is None
-    row = machines.touch_seen(canon, ip=_client_ip(request))
+    default_mode = getattr(request.app.state, "default_boot_mode", DEFAULT_BOOT_MODE)
+    row = machines.touch_seen(canon, ip=_client_ip(request), default_boot_mode=default_mode)
 
     ctx = _render_context(request)
     body = _get_renderer(request).render(row, ctx)

pixie/web/_settings_store.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 
 import contextlib
 import os
+import re
 import sqlite3
 from collections.abc import Generator
 from datetime import UTC, datetime
@@ -66,6 +67,13 @@ DEFAULT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
 KEY_LIVE_ENV_EXTRA_CMDLINE = "live_env.extra_cmdline"
 ENV_LIVE_ENV_EXTRA_CMDLINE = "PIXIE_LIVE_ENV_EXTRA_CMDLINE"
 
+# A value that is nothing but an unexpanded shell placeholder --
+# ``${VAR}`` / ``${VAR:-default}`` / ``${VAR:+x}`` -- which is what a
+# compose runner that doesn't expand ``${VAR:-}`` (podman-compose)
+# leaks into the container env. Such a value is treated as "unset" so
+# it never reaches a kernel cmdline.
+_UNEXPANDED_ENV_PLACEHOLDER = re.compile(r"^\$\{[A-Za-z_][A-Za-z0-9_]*(:[-+?=]?[^}]*)?\}$")
+
 # Where the operator "Fetch live-env" action pulls the netboot-pc bake
 # from: a single tarball ``src`` (``https://`` or ``oras://``, the same
 # schemes the catalog fetch speaks) that unpacks to vmlinuz + initrd +
@@ -78,6 +86,23 @@ DEFAULT_LIVE_ENV_SRC = (
     "https://github.com/safl/pixie/releases/latest/download/pixie-live-env-x86_64.tar.gz"
 )
 
+# Disk-image content sha the live-env boot modes
+# (pixie-inventory / -tui / -flash-once / -flash-always) boot over
+# EPHEMERAL nbdboot instead of the Debian live-boot squashfs. When set
+# (and the named image + its netboot bundle are fetched) the renderer
+# streams this image over NBD -- proven on hardware to bring the NIC up
+# via dracut where the squashfs live-boot hangs in the initramfs on some
+# boards. Empty (the default) keeps the historical squashfs path so
+# existing deploys are untouched. Resolution: DB override -> env ->
+# empty. A value that is not 64 lowercase hex chars is treated as unset
+# so a fat-fingered setting degrades to the squashfs path rather than
+# sending every live-env boot into the unavailable plan.
+KEY_LIVE_ENV_IMAGE_SHA = "live_env.image_sha"
+ENV_LIVE_ENV_IMAGE_SHA = "PIXIE_LIVE_ENV_IMAGE_SHA"
+
+# 64 lowercase hex chars: a catalog entry's ``content_sha256``.
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+
 
 class SettingValueError(ValueError):
     """A stored override failed validation at resolve time. The
@@ -175,12 +200,21 @@ class SettingsStore:
           silently.
 
         Empty when both DB override + env are unset -- the template
-        expects a string and skips the append when it's empty."""
-        return (
-            self.get(KEY_LIVE_ENV_EXTRA_CMDLINE)
-            or (os.environ.get(ENV_LIVE_ENV_EXTRA_CMDLINE) or "").strip()
-            or ""
-        )
+        expects a string and skips the append when it's empty.
+
+        Defends against a compose runner that fails to expand
+        ``${VAR:-}``: podman-compose passes the unset default through
+        LITERALLY, so the container env holds the string
+        ``${PIXIE_LIVE_ENV_EXTRA_CMDLINE:-}``. A value that is nothing
+        but an unexpanded ``${...}`` placeholder is treated as empty so
+        it can't leak onto every live-env / nbdboot kernel cmdline."""
+        override = self.get(KEY_LIVE_ENV_EXTRA_CMDLINE)
+        if override:
+            return override
+        env = (os.environ.get(ENV_LIVE_ENV_EXTRA_CMDLINE) or "").strip()
+        if env and not _UNEXPANDED_ENV_PLACEHOLDER.match(env):
+            return env
+        return ""
 
     def resolve_live_env_src(self) -> str:
         """Effective live-env fetch src: DB override -> env -> default
@@ -193,6 +227,29 @@ class SettingsStore:
             or DEFAULT_LIVE_ENV_SRC
         )
 
+    def resolve_live_env_image_sha(self) -> str:
+        """Effective live-env disk-image content sha: DB override -> env
+        -> empty.
+
+        When non-empty (and the named image + its netboot bundle are
+        fetched) the live-env boot modes nbdboot this image ephemerally
+        instead of fetching the Debian live-boot squashfs. Empty is the
+        default and keeps the squashfs path, so an existing deploy that
+        never sets this is untouched.
+
+        A value that is not 64 lowercase hex chars is treated as unset:
+        the renderer then falls back to the squashfs path rather than
+        degrading every live-env boot to the unavailable plan. The
+        Settings / Live env form validates the shape at set time, so a
+        bad value can only reach here from a stray env-var."""
+        override = self.get(KEY_LIVE_ENV_IMAGE_SHA)
+        if override and _SHA256_RE.match(override.strip()):
+            return override.strip()
+        env = (os.environ.get(ENV_LIVE_ENV_IMAGE_SHA) or "").strip()
+        if env and _SHA256_RE.match(env):
+            return env
+        return ""
+
 
 def parse_iso_utc(raw: str) -> datetime | None:
     """Parse the ISO-8601 strings pixie writes to state.db. Accepts a

pixie/web/_templates/live_env.html

@@ -158,6 +158,42 @@
                 </span>
             </div>
         </form>
+
+        <hr class="my-4">
+
+        <form method="post" action="/ui/live-env/image/edit" class="row g-3">
+            <div class="col-12">
+                <label for="live_env_image_sha" class="form-label">
+                    Boot live env as disk image (nbdboot)
+                    <span class="badge text-bg-{% if live_env_image_sha.override %}primary{% else %}secondary{% endif %} ms-1">
+                        {% if live_env_image_sha.override %}override{% elif live_env_image_sha.effective %}env{% else %}default{% endif %}
+                    </span>
+                </label>
+                <input type="text" id="live_env_image_sha" name="live_env_image_sha"
+                       class="form-control font-monospace"
+                       value="{{ live_env_image_sha.override }}"
+                       placeholder="(unset - use the live-boot squashfs above)"
+                       pattern="[0-9a-fA-F]{64}">
+                <div class="form-text">
+                    A fetched disk-image's <code>content_sha256</code> (64 hex). When set - and that
+                    image plus its netboot bundle are fetched - the <code>pixie-inventory</code> /
+                    <code>pixie-tui</code> / <code>pixie-flash-*</code> modes boot it over
+                    <strong>ephemeral nbdboot</strong> instead of fetching the squashfs. dracut brings
+                    the NIC up where the live-boot squashfs hangs in the initramfs on some boards; the
+                    on-target pixie CLI still phones home so inventory / flash work unchanged. Blank
+                    falls back to <code>{{ live_env_image_sha.env }}</code> then the squashfs path.
+                    Effective:
+                    {% if live_env_image_sha.effective %}<code>{{ live_env_image_sha.effective }}</code>{% else %}<em class="text-muted">(none - squashfs)</em>{% endif %}.
+                    {% if live_env_image_sha.updated_at %}<br>Last updated: <code>{{ live_env_image_sha.updated_at | fmt_ts }}</code>.{% endif %}
+                </div>
+            </div>
+            <div class="col-12">
+                <button type="submit" class="btn btn-primary"><i class="bi bi-check2 me-1"></i>Save</button>
+                <span class="text-muted small ms-2">
+                    Takes effect on the NEXT <code>GET /pxe/&lt;mac&gt;</code>; a target already mid-boot must be power-cycled.
+                </span>
+            </div>
+        </form>
     </div>
 </div>
 

pixie/web/main.py

@@ -66,7 +66,12 @@ from pixie.exports._routes import router as exports_router
 from pixie.exports._store import ExportsStore, OverlaysStore
 from pixie.exports._supervisor import DEFAULT_PORT_BASE, NbdServer
 from pixie.machines._routes import router as machines_router
-from pixie.machines._store import IMAGE_BOOT_MODES, MachinesStore
+from pixie.machines._store import (
+    BOOT_MODES,
+    DEFAULT_BOOT_MODE,
+    IMAGE_BOOT_MODES,
+    MachinesStore,
+)
 from pixie.pxe._renderer import PlanRenderer
 from pixie.pxe._routes import router as pxe_router
 from pixie.tftp import DEFAULT_TFTP_ROOT, TftpServer
@@ -82,6 +87,7 @@ from pixie.web._settings_store import (
     KEY_DATETIME_FORMAT,
     KEY_DISPLAY_TZ,
     KEY_LIVE_ENV_EXTRA_CMDLINE,
+    KEY_LIVE_ENV_IMAGE_SHA,
     KEY_LIVE_ENV_SRC,
     SettingsStore,
     SettingValueError,
@@ -183,6 +189,18 @@ def _resolve_live_env_dir() -> Path | None:
     return default
 
 
+def _resolve_default_boot_mode() -> str:
+    """Boot mode a freshly-discovered MAC auto-registers with.
+
+    ``PIXIE_DEFAULT_BOOT_MODE`` override -> :data:`DEFAULT_BOOT_MODE`
+    (``pixie-inventory``). An unknown value falls back to the default
+    rather than seeding an unrenderable mode on every new machine."""
+    override = (os.environ.get("PIXIE_DEFAULT_BOOT_MODE") or "").strip()
+    if override in BOOT_MODES:
+        return override
+    return DEFAULT_BOOT_MODE
+
+
 def _resolve_state_dir() -> Path:
     """Where pixie writes state.db + blobs/ + artifacts/.
 
@@ -405,6 +423,18 @@ def _deployment_envvar_docs() -> list[dict[str, str]]:
                 " the Live env page for the live-editable override."
             ),
         },
+        {
+            "name": "PIXIE_DEFAULT_BOOT_MODE",
+            "default": "pixie-inventory",
+            "purpose": (
+                "Boot mode a freshly-discovered MAC auto-registers with."
+                " Default 'pixie-inventory' is non-destructive (collects"
+                " lshw + disks, posts them, exits) and one-shot: the first"
+                " inventory POST flips it to 'ipxe-exit' so a PXE-first"
+                " box does not re-inventory. Set 'ipxe-exit' for the old"
+                " exit-by-default behaviour."
+            ),
+        },
         {
             "name": "PIXIE_LIVE_ENV_SRC",
             "default": (
@@ -419,6 +449,20 @@ def _deployment_envvar_docs() -> list[dict[str, str]]:
                 " Live env page."
             ),
         },
+        {
+            "name": "PIXIE_LIVE_ENV_IMAGE_SHA",
+            "default": "",
+            "purpose": (
+                "Disk-image content sha (64 hex) the live-env boot modes"
+                " boot over EPHEMERAL nbdboot instead of the Debian"
+                " live-boot squashfs. When set (and the image + its"
+                " netboot bundle are fetched) the pixie-inventory / -tui /"
+                " -flash-* modes stream this image over NBD -- dracut"
+                " brings the NIC up where the squashfs live-boot hangs on"
+                " some boards. Empty keeps the squashfs path. Live-editable"
+                " override on the Live env page."
+            ),
+        },
         {
             "name": "PIXIE_SEED_CATALOG",
             "default": "1",
@@ -726,6 +770,7 @@ def create_app() -> FastAPI:
         nbdkit_bin=_resolve_nbdkit_bin(),
     )
     app.state.live_env_dir = _resolve_live_env_dir()
+    app.state.default_boot_mode = _resolve_default_boot_mode()
     # Root for per-machine qcow2 overlay files. Sub-directory under
     # the state dir so a single ``PIXIE_DATA_DIR`` override still
     # relocates everything (catalog blobs + overlays + state.db)
@@ -2520,6 +2565,13 @@ def create_app() -> FastAPI:
                 "env": "PIXIE_LIVE_ENV_EXTRA_CMDLINE",
                 "updated_at": store.updated_at(KEY_LIVE_ENV_EXTRA_CMDLINE) or "",
             },
+            "live_env_image_sha": {
+                "override": store.get(KEY_LIVE_ENV_IMAGE_SHA) or "",
+                "effective": store.resolve_live_env_image_sha(),
+                "default": "",
+                "env": "PIXIE_LIVE_ENV_IMAGE_SHA",
+                "updated_at": store.updated_at(KEY_LIVE_ENV_IMAGE_SHA) or "",
+            },
             "flash_error": flash_error,
         }
 
@@ -2580,6 +2632,43 @@ def create_app() -> FastAPI:
             store.clear(KEY_LIVE_ENV_SRC)
         return RedirectResponse(url="/ui/live-env", status_code=status.HTTP_303_SEE_OTHER)
 
+    @app.post("/ui/live-env/image/edit", response_model=None)
+    def ui_live_env_image_edit(
+        request: Request,
+        live_env_image_sha: str = Form(""),
+        _auth: None = Depends(_require_ui_auth),
+    ) -> HTMLResponse | RedirectResponse:
+        """Persist the live-env disk-image content sha. When set (and the
+        image + its netboot bundle are fetched) the live-env boot modes
+        nbdboot this image ephemerally instead of fetching the squashfs.
+        Blank clears the override so the value falls back to
+        $PIXIE_LIVE_ENV_IMAGE_SHA then empty (the squashfs path). Rejects
+        anything that is not 64 lowercase hex chars so a fat-fingered sha
+        doesn't quietly send every live-env boot into the unavailable
+        plan."""
+        import re as _re
+
+        store: SettingsStore = request.app.state.settings_store
+        raw = (live_env_image_sha or "").strip().lower()
+        if raw and not _re.match(r"^[0-9a-f]{64}$", raw):
+            return templates.TemplateResponse(
+                request,
+                "live_env.html",
+                _live_env_context(
+                    request,
+                    flash_error=(
+                        "Live-env image sha must be 64 hex chars "
+                        "(a fetched disk-image's content_sha256)."
+                    ),
+                ),
+                status_code=400,
+            )
+        if raw:
+            store.set_value(KEY_LIVE_ENV_IMAGE_SHA, raw)
+        else:
+            store.clear(KEY_LIVE_ENV_IMAGE_SHA)
+        return RedirectResponse(url="/ui/live-env", status_code=status.HTTP_303_SEE_OTHER)
+
     @app.post("/ui/live-env/fetch")
     def ui_live_env_fetch(
         request: Request,

{pixie_lab-0.4.0.dist-info → pixie_lab-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixie-lab
-Version: 0.4.0
+Version: 0.4.2
 Summary: Bare-metal netboot appliance: catalog + fetch + NBD + PXE + TFTP + operator TUI in one container
 Project-URL: Homepage, https://github.com/safl/pixie
 Project-URL: Repository, https://github.com/safl/pixie

{pixie_lab-0.4.0.dist-info → pixie_lab-0.4.2.dist-info}/RECORD

@@ -1,18 +1,19 @@
 pixie/__init__.py,sha256=XhfE52sqfEOUpzoYuuO8GpRNTCjigL28LBiNKVrHf2A,615
-pixie/_partition.py,sha256=1VS6YutVde5IhgSdzSxmFm67GupfmZyB7gPb8uAofBc,5853
+pixie/_partition.py,sha256=xLQdXGACAAEmt4e1w1SuyhAy-5jZ3hm8oEpCBXw_0Ag,9461
 pixie/_util.py,sha256=dmaialB1eGUJd85oynoJTEAIVb1o2X8XdV_cNbrf6eU,554
 pixie/disks.py,sha256=RTATvHaBEpDJzC5y1YiLe1P1GzkHfTDRRMUZDbCdPio,3388
 pixie/flash.py,sha256=X1gnwq2mhzo8CmrZQgcA5RowFjHKLbRPkHUc8976bVc,78373
 pixie/images.py,sha256=zteGZkPeMdwCiA5oUXYl2mhqjAITi30HuWRvkY1z6BQ,17450
 pixie/oras.py,sha256=zKKqYcSghgguOIIrGcJ6C3hZusmORZmDfv7zZDDFslM,22509
+pixie/oras_pull.py,sha256=Xyqga4o8vtCZrUSv5YgLggqmXs36y6FXd-_E9a_iRVo,3326
 pixie/tui_catalog.py,sha256=nKiVd-SC_qfS3m6phQXRnqQdKN_nTqZbQFl2cIscIoQ,26305
 pixie/catalog/__init__.py,sha256=DWBJOL0goBieMLWFO2RXTc_w6e0OQ3f6qQVn-oiTq3c,2309
-pixie/catalog/_fetcher.py,sha256=URy7doSFFzWgDQOgw4uV3fr0u5_hjHuhNH76l5-2UFU,26295
+pixie/catalog/_fetcher.py,sha256=xiMLccBoJsjNumy1DT38aJiqM4-wYSzHGtklRKnKWlE,26698
 pixie/catalog/_live_env.py,sha256=DWbPecbipSZ4KQAx60yi4q_gFncOZt4f1yj-QZ7ZBV0,5068
 pixie/catalog/_routes.py,sha256=8s_8bEDYL5zwg6gNAtxR7NOGPLY7ho9spqjPU83RIPE,14729
 pixie/catalog/_schema.py,sha256=KC6RcKlToX1DgcRjn25djKMx78-eS-4WzNRY267h0I0,9769
 pixie/catalog/_store.py,sha256=S7OM7A05Y5ES4RuhmwqQupDGNWXF--p_UMfUNOgQHsQ,9044
-pixie/catalog/catalog.toml,sha256=UQZPLk0f_rw6XVZDJQ7zq3yMRhfKEFxNVbDP_BA6_vs,3552
+pixie/catalog/catalog.toml,sha256=nL97qrh0IkfTFmaSMMzWPBi465V9_R6aFcSjzKHKi14,4883
 pixie/deploy/__init__.py,sha256=3PvSvrIRdqxLCz0nTdVSBiPzEtDl359XSUBgyMBkMT8,1019
 pixie/deploy/_main.py,sha256=Or2espz9oWNmnGfyEzIsEyvRwWEHL4uxyE6U9OdMZJs,15403
 pixie/deploy/_templates.py,sha256=WkkKRDU00FDWVZM0XeKR-BCtSBPvaZ2QHM1TBeq0RYg,5418
@@ -25,13 +26,13 @@ pixie/exports/_routes.py,sha256=y6exOqYA4KtN3mHbYJWqHTOaQHk_OaaUWosotAX6NgM,7569
 pixie/exports/_store.py,sha256=MCRwzsbCD2VdFGLHGyshCqnmD0Axm9GyQIZBOgK2FxE,13829
 pixie/exports/_supervisor.py,sha256=jOR8S1f8btmvngEQNVGZQ2-pcxmn_xU1rlviCjMUrW4,14623
 pixie/machines/__init__.py,sha256=iSyEkYm6_oP5TNRVks-HrudMjX2Wr7v6t3RSOyl3eps,725
-pixie/machines/_routes.py,sha256=gVtDYF3R9RxeX4EtvtKW5O1VURRE2vuy2Odbfbf4uKs,8601
-pixie/machines/_store.py,sha256=e490q7pLJFHf7sru10njcUcyBQJEfBJdwBGL8iJ3nzk,28894
+pixie/machines/_routes.py,sha256=I5o_pLYIUya-N7Z23YRZZUEY9-_PMJJbHtZFTWm8SDM,8731
+pixie/machines/_store.py,sha256=zh89zj2s5CurMFO258i10ANW20VCTQk0kT8MgRhnWi0,30379
 pixie/pivot/__init__.py,sha256=k_yIUOrIu-DKCJ_8XmRtnoVV7Rr9URagHU2Y76HB2ew,6195
 pixie/pivot/nbdboot,sha256=stBWGXnSXMFJMMzmtip77dPwWxQLfOewXo9YOgw5u0I,19558
 pixie/pxe/__init__.py,sha256=AKBRKQYdlH7DdNBvES9EwYTzPOkeNbWBN1S7IH1UEyw,784
-pixie/pxe/_renderer.py,sha256=FE9Ih_ZUoDLwXxLuUVX2h1LWK2TZnfW2oOBIfdn04Nc,15016
-pixie/pxe/_routes.py,sha256=a903n3t43LGNqLYJ4f704o4C73cDZuMVluC3eWPAibM,17239
+pixie/pxe/_renderer.py,sha256=Tg2oMZQ_vSkEmsc2Rn_SXZ6Ed14LXUmZTOgzkLQC56g,18833
+pixie/pxe/_routes.py,sha256=VhWH5VXaaAC39Bt3asZPpp9ckTCOJdJx3DOLFVTn-2M,19169
 pixie/tftp/__init__.py,sha256=FuHn1KF5_NoGOM_dHXSbubX5lJr0tuMugJGFxxwuUws,774
 pixie/tftp/_supervisor.py,sha256=khpjgWqdMzdnhRaPYM4j25PoKijbBnvr-GjJLybP_rY,4659
 pixie/tui/__init__.py,sha256=EgULtZPOjzs66FosDeSGLFqacsSkal_xBmpBy0fIeZ8,8563
@@ -44,9 +45,9 @@ pixie/web/_images.py,sha256=RhtTmzRhapr6zRbQN4SKaW_o3dhUhf6hyZGIlbxMh_k,6993
 pixie/web/_inventory.py,sha256=rJDNAfejmtlNPCPUr2mhLey19C5Tu_dmpia9KVeyT7E,10189
 pixie/web/_overlay_bind.py,sha256=7aKYqMaujxt-XRa1jB6mVEkbt-w_koXjLvUzBTzy2o8,4125
 pixie/web/_overlays.py,sha256=5yZp6pDiFj_WKdLx6vCoEKD8mXG3KjkMOQt4OGYYdyc,8571
-pixie/web/_settings_store.py,sha256=qV_BB7PvCM61jbOR-RV9sxR30XJ28xOKPkc1TDMKYXo,9429
+pixie/web/_settings_store.py,sha256=TrhjRN2ME1K3VsgJPJif7ZA3Tf7pM9k9oL57Hhh_YH0,12409
 pixie/web/_table_state.py,sha256=zGH5oZ-XlMqUFQqmYglYqT_fu1Yrtaw-g5yhPtAKAEc,9524
-pixie/web/main.py,sha256=Be-abz0S7ORp-CEyIWf2FZcElmUHRJUYaA5n0U0Xjb4,113150
+pixie/web/main.py,sha256=1eu183QjBjcN5yKuFn0TGD5rNaDuF6U4TPED29EsSJ0,117004
 pixie/web/_static/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixie/web/_static/bootstrap-icons.min.css,sha256=pdY4ejLKO67E0CM2tbPtq1DJ3VGDVVdqAR6j3ZwdiE4,87008
 pixie/web/_static/bootstrap.min.css,sha256=NXgoHLHuUWz0lbqh8PRwCIl7_QhZE74v-FCwrYdCW1E,234717
@@ -62,7 +63,7 @@ pixie/web/_templates/events.html,sha256=ifawe--m5FMcicKZ2daCCycV7rGgpLJz7A309UrT
 pixie/web/_templates/image_detail.html,sha256=--DjHCDgvripwr-9_lmnmaLCe4Iw2W_gXIGuKLMvcJw,6926
 pixie/web/_templates/images.html,sha256=PO8r0hZ6tXMqHZo_m1t_wgh4NEZP6u_72owH_Jbz2Zo,7266
 pixie/web/_templates/layout.html,sha256=9kQ1sWyAqMl9YgwJO1jIjwRbiG8bt2sUpJLNrbBZmzo,13988
-pixie/web/_templates/live_env.html,sha256=Z9EuvhUpwljXm8Y_wC2B0y4STvQUZYoBMG8aQvj2PsQ,9122
+pixie/web/_templates/live_env.html,sha256=0goOWgrCXvONHEyZSGfqG6h_B0rPaEHvw7Cbt-UpL4I,11557
 pixie/web/_templates/login.html,sha256=d60N8kmr7YaAoTKRBaOiGN5Srdy8-BgB8_Zz9TQvGwc,1810
 pixie/web/_templates/machine_detail.html,sha256=ijI5FKuyqOdDwCdLGM_H7yHgqn6fFMm6pOPVBLT9G00,49797
 pixie/web/_templates/machines.html,sha256=modlu9MNqpxOkDd90o-yV1g5yuEiC61I6JtXQk7_PUo,9803
@@ -76,8 +77,8 @@ pixie/web/_templates/ipxe/exit.j2,sha256=pbTXTwjgiEsPZlRuv7_J0Q3BepXEqXnb82mv1sx
 pixie/web/_templates/ipxe/nbdboot.j2,sha256=s1CwIKou5W6LRoC2MdZYwA3RcRN8AU3B1gbJmGLS9MM,3950
 pixie/web/_templates/ipxe/pixie-live-env.j2,sha256=dPWuYCFrkXwwatPSnTRSfWuMUMgvs3VLDHqbJTG1pP0,3048
 pixie/web/_templates/ipxe/unavailable.j2,sha256=zt4DYfYRXmOIjL13diYPxEApTP3CRnn5Beszeh3BPBw,440
-pixie_lab-0.4.0.dist-info/METADATA,sha256=lAZwK9_NRBjEnkA2LQ_6skrbDSho5lrgpBWKFd-CwfI,4452
-pixie_lab-0.4.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-pixie_lab-0.4.0.dist-info/entry_points.txt,sha256=G3vtKpg_gQtisiyS31EjdvC4QC52Kfw2K7iMsfsnj5A,71
-pixie_lab-0.4.0.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-pixie_lab-0.4.0.dist-info/RECORD,,
+pixie_lab-0.4.2.dist-info/METADATA,sha256=KVZwvaxEXtrV_qtKhwUyIqJtMBUxyeYx6qyWC4zz_nc,4452
+pixie_lab-0.4.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+pixie_lab-0.4.2.dist-info/entry_points.txt,sha256=G3vtKpg_gQtisiyS31EjdvC4QC52Kfw2K7iMsfsnj5A,71
+pixie_lab-0.4.2.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+pixie_lab-0.4.2.dist-info/RECORD,,