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

pixie/events/_kinds.py

@@ -197,24 +197,6 @@ right after the wipe so the freshly-empty log still records who reset
 it and when; carries the deleted-row count in ``details``."""
 
 # ---------- live-env fetch ------------------------------------------
-#
-# The operator "Fetch live-env" action pulls the netboot-pc bake into
-# PIXIE_LIVE_ENV_DIR. No subject (``subject_kind`` = ""): the live env
-# is per-pixie, not per-resource. Dotted ``.done`` / ``.failed`` names
-# mirror the catalog-fetch kinds so ``.failed`` auto-classifies as an
-# error via the ERROR_KINDS ``LIKE '%.failed'`` probe.
-
-LIVE_ENV_FETCH_DONE = "live_env.fetch.done"
-"""``POST /ui/live-env/fetch`` downloaded + staged vmlinuz + initrd +
-live.squashfs into PIXIE_LIVE_ENV_DIR. Carries the src + content sha in
-``details``."""
-
-LIVE_ENV_FETCH_FAILED = "live_env.fetch.failed"
-"""The live-env fetch failed (bad src scheme, download error, or a
-tarball missing a required file). Carries the src + error in
-``details``."""
-
-
 # The canonical closed set. Every kind above is registered here; the
 # ``EventsLog.emit`` call rejects anything not in this frozenset.
 KNOWN_EVENT_KINDS: frozenset[str] = frozenset(
@@ -248,8 +230,6 @@ KNOWN_EVENT_KINDS: frozenset[str] = frozenset(
         AUTH_LOGIN_SUCCEEDED,
         AUTH_LOGIN_FAILED,
         EVENTS_CLEARED,
-        LIVE_ENV_FETCH_DONE,
-        LIVE_ENV_FETCH_FAILED,
     }
 )
 

pixie/pxe/_renderer.py

@@ -91,12 +91,12 @@ class RenderContext:
     # 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
+    # ephemeral nbdboot. Operator-set via PIXIE_LIVE_ENV_IMAGE_SHA /
+    # the Live env page. Empty means no live-env image is configured,
+    # so LIVE_ENV_MODES machines degrade to the ``unavailable`` plan;
+    # 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 = ""
 
@@ -113,7 +113,6 @@ class PlanRenderer:
         overlays: OverlaysStore,
         nbd: NbdServer,
         overlays_dir: Path,
-        live_env_dir: Path | None = None,
         events: Any = None,
     ) -> None:
         self._catalog = catalog
@@ -128,29 +127,12 @@ class PlanRenderer:
         # booted) land alongside the rest of pixie's audit trail. None
         # for unit tests that don't wire an events sink.
         self._events = events
-        # Where the netboot-pc bake's vmlinuz + initrd + squashfs are
-        # staged on disk. When set + the three files exist, the
-        # ``pixie-*`` boot modes chain into the live env; otherwise
-        # they fall back to the ``unavailable`` plan so a bound
-        # target does not silently boot nothing.
-        self._live_env_dir = live_env_dir
         self._env = Environment(
             loader=FileSystemLoader(str(_TEMPLATES_DIR)),
             autoescape=select_autoescape(disabled_extensions=("j2",)),
             keep_trailing_newline=True,
         )
 
-    def _live_env_ready(self) -> bool:
-        """True iff the netboot-pc artifacts are staged on disk under
-        ``self._live_env_dir``. Called per-render so an operator
-        dropping the files in without a pixie restart takes effect
-        on the next PXE hit."""
-        if self._live_env_dir is None:
-            return False
-        return all(
-            (self._live_env_dir / name).is_file() for name in ("vmlinuz", "initrd", "live.squashfs")
-        )
-
     def render(self, machine: Machine, ctx: RenderContext) -> str:
         mode = machine.boot_mode
         # Per-machine ``extra_cmdline`` fully overrides the deploy-wide
@@ -341,52 +323,37 @@ class PlanRenderer:
     ) -> 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
+        The live env boots the disk image named by
+        ``ctx.live_env_image_sha`` (PIXIE_LIVE_ENV_IMAGE_SHA / the Live
+        env page) over EPHEMERAL nbdboot, the same code path the
+        ``nbdboot`` mode uses -- proven on hardware to bring the NIC up
+        via dracut where the retired Debian live-boot squashfs hung in
+        the initramfs on some boards. If no image is configured, or the
+        configured image / its netboot bundle isn't fetched, degrade to
+        ``unavailable`` (matching how ``nbdboot`` degrades) rather than
+        booting nothing -- a live-env mode with no bootable image is an
+        operator setup gap worth surfacing.
+
+        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."""
+        dispatches inventory / interactive / flash accordingly."""
         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 live_env_sha:
+            return self._unavailable(
+                machine,
+                f"boot_mode={mode!r} needs a live-env image; set "
+                "PIXIE_LIVE_ENV_IMAGE_SHA (or the Live env page) to a "
+                "fetched image's content sha",
             )
-        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.
+        resolved = self._resolve_bundle_and_blob(live_env_sha)
+        if isinstance(resolved, str):
             return self._unavailable(
                 machine,
-                f"boot_mode={mode!r} needs pixie live-env media; "
-                f"stage vmlinuz+initrd+squashfs under $PIXIE_LIVE_ENV_DIR",
+                f"live-env image {live_env_sha[:12]} not bootable: {resolved}",
             )
-        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,
+        bundle_entry, blob = resolved
+        return self._render_ephemeral_nbdboot(
+            machine, ctx, live_env_sha, bundle_entry, blob, extra_cmdline
         )
 
     def _unavailable(self, machine: Machine, reason: str) -> str:

pixie/web/_settings_store.py

@@ -74,29 +74,16 @@ ENV_LIVE_ENV_EXTRA_CMDLINE = "PIXIE_LIVE_ENV_EXTRA_CMDLINE"
 # 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 +
-# live.squashfs. Defaults to the pixie GitHub release's stable-named
-# asset via ``/releases/latest/download/`` so a plain deploy can pull
-# the live env with no config; override for an air-gapped mirror.
-KEY_LIVE_ENV_SRC = "live_env.src"
-ENV_LIVE_ENV_SRC = "PIXIE_LIVE_ENV_SRC"
-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.
+# EPHEMERAL nbdboot. 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 retired squashfs
+# live-boot hung in the initramfs on some boards. Empty (the default)
+# means those modes degrade to the unavailable plan. 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 unavailable
+# cleanly.
 KEY_LIVE_ENV_IMAGE_SHA = "live_env.image_sha"
 ENV_LIVE_ENV_IMAGE_SHA = "PIXIE_LIVE_ENV_IMAGE_SHA"
 
@@ -216,17 +203,6 @@ class SettingsStore:
             return env
         return ""
 
-    def resolve_live_env_src(self) -> str:
-        """Effective live-env fetch src: DB override -> env -> default
-        (the pixie GitHub release asset). Never empty; the caller feeds
-        it straight to the live-env fetch, which raises on a bad
-        scheme."""
-        return (
-            self.get(KEY_LIVE_ENV_SRC)
-            or (os.environ.get(ENV_LIVE_ENV_SRC) or "").strip()
-            or DEFAULT_LIVE_ENV_SRC
-        )
-
     def resolve_live_env_image_sha(self) -> str:
         """Effective live-env disk-image content sha: DB override -> env
         -> empty.

pixie/web/_templates/dashboard.html

@@ -126,67 +126,45 @@
     </div>
 </div>
 
-{# Live-env media readiness (OUTPUT ONLY). The dashboard reports
-   whether the pixie-* boot modes have their media; the Fetch action +
-   source / cmdline config live on the dedicated /ui/live-env pane. #}
-{% set lfs = stats.live_env_fetch_state or {} %}
+{# Live-env readiness (OUTPUT ONLY). The dashboard reports whether the
+   pixie-* boot modes have a bootable image selected; the image + cmdline
+   config live on the dedicated /ui/live-env pane. #}
 <div class="card shadow-sm mb-4">
     <div class="card-header bg-light d-flex align-items-center gap-2">
-        <h2 class="h5 mb-0"><i class="bi bi-boombox me-2"></i>Live-env media</h2>
+        <h2 class="h5 mb-0"><i class="bi bi-boombox me-2"></i>Live env</h2>
         <div class="ms-auto d-flex align-items-center gap-2">
-            {% if lfs.state == 'fetching' %}
-            <span class="badge text-bg-info"><span class="spinner-border spinner-border-sm me-1" role="status"></span>fetching</span>
-            {% elif stats.live_env_ready %}
+            {% if stats.live_env_ready %}
             <span class="badge text-bg-success"><i class="bi bi-check-circle me-1"></i>ready</span>
             {% else %}
-            <span class="badge text-bg-warning"><i class="bi bi-exclamation-triangle me-1"></i>not staged</span>
+            <span class="badge text-bg-warning"><i class="bi bi-exclamation-triangle me-1"></i>not ready</span>
             {% endif %}
             <a href="/ui/live-env" class="btn btn-sm btn-outline-primary text-nowrap"
-               title="Fetch + configure the live env">
+               title="Select + configure the live env">
                 <i class="bi bi-boombox me-1"></i>Manage
             </a>
         </div>
     </div>
     <div class="card-body">
         {% if stats.live_env_ready %}
-        <p class="small mb-2">
-            Staged at <code>{{ stats.live_env_dir }}</code>;
+        <p class="small mb-0">
+            Image <code>{{ stats.live_env_image_sha[:12] }}</code> selected and fetched;
             <code>pixie-tui</code> / <code>pixie-inventory</code> /
-            <code>pixie-flash-*</code> can serve the live env.
+            <code>pixie-flash-*</code> boot it over ephemeral nbdboot.
         </p>
-        {% else %}
-        <p class="small text-warning mb-2">
-            Live-env media is missing under <code>{{ stats.live_env_dir or '(unset)' }}</code>.
-            Every <code>pixie-*</code> boot_mode falls back to the "unavailable" iPXE
-            plan until it is staged. <a href="/ui/live-env">Fetch it &rarr;</a>
+        {% elif stats.live_env_image_sha %}
+        <p class="small text-warning mb-0">
+            Live-env image <code>{{ stats.live_env_image_sha[:12] }}</code> is selected but
+            not fetched. Every <code>pixie-*</code> boot_mode falls back to the "unavailable"
+            iPXE plan until the image is fetched. <a href="/ui/catalog">Fetch it &rarr;</a>
         </p>
-        {% endif %}
-        {% if lfs.state == 'error' %}
-        <p class="small text-danger mb-2">
-            <i class="bi bi-exclamation-triangle me-1"></i>Last fetch failed &mdash; see
-            <a href="/ui/live-env">Live env</a>.
+        {% else %}
+        <p class="small text-warning mb-0">
+            No live-env image selected. Every <code>pixie-*</code> boot_mode falls back to the
+            "unavailable" iPXE plan until one is set. <a href="/ui/live-env">Select it &rarr;</a>
         </p>
         {% endif %}
-        <dl class="row small mb-0">
-            {% for name, size in stats.live_env_files.items() %}
-            <dt class="col-sm-3 font-monospace">{{ name }}</dt>
-            <dd class="col-sm-9">
-                {% if size is not none %}
-                <span class="text-success"><i class="bi bi-check-circle me-1"></i>{{ (size / 1024 / 1024) | round(1) }} MiB</span>
-                {% else %}
-                <span class="text-warning"><i class="bi bi-x-circle me-1"></i>missing</span>
-                {% endif %}
-            </dd>
-            {% endfor %}
-        </dl>
     </div>
 </div>
-{% if lfs.state == 'fetching' %}
-{# The fetch runs on the server's thread pool; poll the page so the
-   spinner flips to "ready" (or an error) on its own. A big squashfs
-   download takes a while, so 5 s is frequent enough without hammering. #}
-<script>setTimeout(function () { location.reload(); }, 5000);</script>
-{% endif %}
 
 <div class="card shadow-sm">
     <div class="card-header bg-light d-flex align-items-center">

pixie/web/_templates/live_env.html

@@ -6,8 +6,7 @@
 <nav class="navbar subnav-strip" aria-label="Section sub-navigation">
     <div class="container">
         <span class="subnav-jumps d-flex align-items-center flex-wrap">
-            <a href="#media">Media</a>
-            <a href="#fetch">Fetch</a>
+            <a href="#image">Image</a>
             <a href="#options">Options</a>
         </span>
     </div>
@@ -15,104 +14,64 @@
 {% endblock %}
 
 {% block content %}
-{% set lfs = live_env_fetch_state or {} %}
-{{ page_description('boombox', 'The pixie live env (netboot-pc bake: vmlinuz + initrd + live.squashfs) that the pixie-flash-once / pixie-flash-always / pixie-inventory / pixie-tui boot modes chain into. Fetch it from the configured source, or point that source at a mirror. Until all three files are staged, those boot modes fall back to an "unavailable" iPXE plan.') }}
+{{ page_description('boombox', 'The pixie live env that the pixie-flash-once / pixie-flash-always / pixie-inventory / pixie-tui boot modes boot into. It is a fetched disk image (the pixie-live-env catalog entry) booted over ephemeral nbdboot: select it here by content sha. Until an image is selected and fetched, those boot modes fall back to an "unavailable" iPXE plan.') }}
 
 {% if flash_error %}
 <div class="alert alert-danger py-2">{{ flash_error }}</div>
 {% endif %}
 
-{# ---- Media state (output) --------------------------------------- #}
-<div class="card shadow-sm mb-4" id="media">
+{# ---- Live-env image (the nbdboot selector) ---------------------- #}
+<div class="card shadow-sm mb-4" id="image">
     <div class="card-header bg-light d-flex align-items-center gap-2">
-        <h2 class="h5 mb-0"><i class="bi bi-boombox me-2"></i>Staged media</h2>
-        {% if live_env_ready %}
-        <span class="badge text-bg-success ms-auto"><i class="bi bi-check-circle me-1"></i>ready</span>
+        <h2 class="h5 mb-0"><i class="bi bi-boombox me-2"></i>Live-env image</h2>
+        {% if live_env_image_sha.effective %}
+        <span class="badge text-bg-success ms-auto"><i class="bi bi-check-circle me-1"></i>selected</span>
         {% else %}
-        <span class="badge text-bg-warning ms-auto"><i class="bi bi-exclamation-triangle me-1"></i>not staged</span>
+        <span class="badge text-bg-warning ms-auto"><i class="bi bi-exclamation-triangle me-1"></i>none selected</span>
         {% endif %}
     </div>
     <div class="card-body">
-        <p class="small text-muted mb-2">
-            Staged under <code>{{ live_env_dir or '(unset)' }}</code>, served to targets at
-            <code>/boot/pixie-live-env/</code>. The renderer re-checks these files on every
-            <code>GET /pxe/&lt;mac&gt;</code>, so a fresh fetch takes effect without a restart.
+        <p class="small text-muted mb-3">
+            Fetch the <code>pixie-live-env</code> image on the
+            <a href="/ui/catalog">Catalog</a> page, then paste its
+            <code>content_sha256</code> here. The
+            <code>pixie-inventory</code> / <code>pixie-tui</code> /
+            <code>pixie-flash-*</code> modes boot it over
+            <strong>ephemeral nbdboot</strong> (a RO NBD lower + tmpfs
+            overlay); dracut brings the NIC up where the retired
+            live-boot squashfs hung in the initramfs on some boards. The
+            on-target pixie CLI phones home so inventory / flash work as
+            before.
         </p>
-        <dl class="row small mb-0">
-            {% for name, size in live_env_files.items() %}
-            <dt class="col-sm-3 font-monospace">{{ name }}</dt>
-            <dd class="col-sm-9">
-                {% if size is not none %}
-                <span class="text-success"><i class="bi bi-check-circle me-1"></i>{{ (size / 1024 / 1024) | round(1) }} MiB</span>
-                {% else %}
-                <span class="text-warning"><i class="bi bi-x-circle me-1"></i>missing</span>
-                {% endif %}
-            </dd>
-            {% endfor %}
-        </dl>
-    </div>
-</div>
-
-{# ---- Fetch (action) --------------------------------------------- #}
-<div class="card shadow-sm mb-4" id="fetch">
-    <div class="card-header bg-light fw-semibold">
-        <i class="bi bi-cloud-download me-1"></i>Fetch live env
-    </div>
-    <div class="card-body">
-        {% if lfs.state == 'fetching' %}
-        <div class="alert alert-info py-2 small">
-            <span class="spinner-border spinner-border-sm me-1" role="status"></span>
-            Fetching live-env{% if lfs.phase %} ({{ lfs.phase }}){% endif %}... this can take a while for the ~1&nbsp;GiB squashfs.
-        </div>
-        {% elif lfs.state == 'error' %}
-        <div class="alert alert-danger py-2 small">
-            <i class="bi bi-exclamation-triangle me-1"></i>Last fetch failed: {{ lfs.error }}
-        </div>
-        {% elif lfs.state == 'done' %}
-        <div class="alert alert-success py-2 small">
-            <i class="bi bi-check-circle me-1"></i>Last fetch staged the live env{% if lfs.sha256 %} (sha {{ lfs.sha256[:12] }}){% endif %}.
-        </div>
-        {% endif %}
-
-        {# Editable source, then the fetch button that consumes it. #}
-        <form method="post" action="/ui/live-env/src/edit" class="row g-2 align-items-end mb-3">
-            <div class="col-12 col-lg-9">
-                <label for="live_env_src" class="form-label mb-1">
-                    Source
-                    <span class="badge text-bg-{% if live_env_src.override %}primary{% else %}secondary{% endif %} ms-1">
-                        {% if live_env_src.override %}override{% elif live_env_src.effective != live_env_src.default %}env{% else %}default{% endif %}
+        <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">
+                    Image content sha
+                    <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_src" name="live_env_src"
+                <input type="text" id="live_env_image_sha" name="live_env_image_sha"
                        class="form-control font-monospace"
-                       value="{{ live_env_src.override }}"
-                       placeholder="{{ live_env_src.default }}">
-            </div>
-            <div class="col-12 col-lg-3">
-                <button type="submit" class="btn btn-outline-secondary w-100">
-                    <i class="bi bi-check2 me-1"></i>Save source
-                </button>
-            </div>
-            <div class="col-12">
+                       value="{{ live_env_image_sha.override }}"
+                       placeholder="(unset - live-env modes degrade to the unavailable plan)"
+                       pattern="[0-9a-fA-F]{64}">
                 <div class="form-text">
-                    Tarball to download (<code>https://</code> or <code>oras://</code>); must unpack to
-                    <code>vmlinuz</code> + <code>initrd</code> + <code>live.squashfs</code>. Blank falls
-                    back to <code>{{ live_env_src.env }}</code> then the latest pixie GitHub release.
-                    Effective: <code>{{ live_env_src.effective }}</code>.
-                    {% if live_env_src.updated_at %}<br>Last updated: <code>{{ live_env_src.updated_at | fmt_ts }}</code>.{% endif %}
+                    A fetched disk-image's <code>content_sha256</code> (64 hex), plus its
+                    netboot bundle (via the entry's <code>netboot_src</code>), must both be
+                    fetched. Blank falls back to <code>{{ live_env_image_sha.env }}</code>
+                    then unset, in which case the live-env boot modes render the
+                    <code>unavailable</code> plan. Effective:
+                    {% if live_env_image_sha.effective %}<code>{{ live_env_image_sha.effective }}</code>{% else %}<em class="text-muted">(none)</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>
-        </form>
-
-        <form method="post" action="/ui/live-env/fetch" class="m-0">
-            <button type="submit" class="btn btn-primary" {% if lfs.state == 'fetching' %}disabled{% endif %}>
-                {% if lfs.state == 'fetching' %}
-                <span class="spinner-border spinner-border-sm me-1" role="status"></span>Fetching...
-                {% else %}
-                <i class="bi bi-cloud-download me-1"></i>{% if live_env_ready %}Re-fetch live env{% else %}Fetch live env{% endif %}
-                {% endif %}
-            </button>
-            <span class="text-muted small ms-2">Downloads + stages the three files; overwrites what's there.</span>
+            <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>
@@ -158,48 +117,6 @@
                 </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>
-
-{% if lfs.state == 'fetching' %}
-{# The fetch runs on the server's thread pool; reload so the spinner
-   flips to ready / error on its own. #}
-<script>setTimeout(function () { location.reload(); }, 5000);</script>
-{% endif %}
 {% endblock %}

pixie/web/main.py

@@ -55,8 +55,6 @@ from pixie.events._kinds import (
     CATALOG_IMPORT_OK,
     EVENTS_CLEARED,
     EXPORT_NBDKIT_SPAWNED,
-    LIVE_ENV_FETCH_DONE,
-    LIVE_ENV_FETCH_FAILED,
     TFTP_STARTED,
     TFTP_STOPPED,
 )
@@ -83,12 +81,10 @@ from pixie.web._auth import (
     using_default_password,
 )
 from pixie.web._settings_store import (
-    DEFAULT_LIVE_ENV_SRC,
     KEY_DATETIME_FORMAT,
     KEY_DISPLAY_TZ,
     KEY_LIVE_ENV_EXTRA_CMDLINE,
     KEY_LIVE_ENV_IMAGE_SHA,
-    KEY_LIVE_ENV_SRC,
     SettingsStore,
     SettingValueError,
     format_ts,
@@ -101,7 +97,6 @@ _STATIC_DIR = _HERE / "_static"
 
 DEFAULT_STATE_DIR = Path("/var/lib/pixie")
 STATE_DIR_ENV = "PIXIE_DATA_DIR"
-LIVE_ENV_DIR_ENV = "PIXIE_LIVE_ENV_DIR"
 FETCH_POOL_SIZE_ENV = "PIXIE_FETCH_POOL_SIZE"
 DEFAULT_FETCH_POOL_SIZE = 4
 
@@ -171,24 +166,6 @@ def _resolve_tftp_bin() -> str:
     return (os.environ.get(TFTP_BIN_ENV) or "").strip() or DEFAULT_TFTP_BIN
 
 
-def _resolve_live_env_dir() -> Path | None:
-    """Directory holding the pixie netboot-pc bake artifacts
-    (vmlinuz + initrd + squashfs). Default: ``<state_dir>/live-env``.
-    Explicit override via ``PIXIE_LIVE_ENV_DIR``. Returns the resolved
-    path whether or not it exists yet -- readiness is decided per-render
-    by stat'ing the individual files, and the serving mount is created
-    with ``check_dir=False``, so a fresh deploy can stage the artifacts
-    into a running container and have them picked up without a restart."""
-    override = (os.environ.get(LIVE_ENV_DIR_ENV) or "").strip()
-    if override:
-        return Path(override)
-    # Default sits under the state dir so an operator dropping
-    # artifacts into ``/opt/pixie/data/live-env/`` on a compose
-    # deploy is the whole install step.
-    default = _resolve_state_dir() / "live-env"
-    return default
-
-
 def _resolve_default_boot_mode() -> str:
     """Boot mode a freshly-discovered MAC auto-registers with.
 
@@ -403,16 +380,6 @@ def _deployment_envvar_docs() -> list[dict[str, str]]:
                 " live-env by default."
             ),
         },
-        {
-            "name": LIVE_ENV_DIR_ENV,
-            "default": "$PIXIE_DATA_DIR/live-env",
-            "purpose": (
-                "Where the pixie live-env vmlinuz + initrd +"
-                " live.squashfs are staged. The pixie-* boot modes"
-                " degrade to an unavailable plan when this dir is"
-                " missing or incomplete."
-            ),
-        },
         {
             "name": "PIXIE_LIVE_ENV_EXTRA_CMDLINE",
             "default": "",
@@ -435,32 +402,18 @@ def _deployment_envvar_docs() -> list[dict[str, str]]:
                 " exit-by-default behaviour."
             ),
         },
-        {
-            "name": "PIXIE_LIVE_ENV_SRC",
-            "default": (
-                "https://github.com/safl/pixie/releases/latest/download/"
-                "pixie-live-env-x86_64.tar.gz"
-            ),
-            "purpose": (
-                "Tarball the dashboard 'Fetch live-env' action pulls the"
-                " netboot-pc bake from (https:// or oras://). Defaults to"
-                " the latest pixie GitHub release; point at a mirror for"
-                " air-gapped deploys. Live-editable override on the"
-                " 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."
+                " boot over EPHEMERAL nbdboot. 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 retired squashfs"
+                " live-boot hung on some boards. Empty means those modes"
+                " degrade to the unavailable plan. Live-editable override"
+                " on the Live env page."
             ),
         },
         {
@@ -769,7 +722,6 @@ def create_app() -> FastAPI:
         bind=_resolve_nbd_bind(),
         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
@@ -783,7 +735,6 @@ def create_app() -> FastAPI:
         overlays=app.state.overlays_store,
         nbd=app.state.nbd_server,
         overlays_dir=app.state.overlays_dir,
-        live_env_dir=app.state.live_env_dir,
         events=app.state.events_log,
     )
     app.state.tftp_server = (
@@ -801,11 +752,6 @@ def create_app() -> FastAPI:
         thread_name_prefix="pixie-fetch",
     )
     app.state.fetch_states = {}
-    # Single-slot progress dict for the operator "Fetch live-env"
-    # action (there is one live env per pixie, not one per resource).
-    # Shape mirrors a fetch_states entry: state -> fetching / done /
-    # error, plus phase + byte counters while the download runs.
-    app.state.live_env_fetch_state = {}
 
     # SessionMiddleware signs the ``pixie-token`` cookie. Sliding TTL:
     # 7 days from last touch. ``https_only=False`` because pixie is
@@ -845,28 +791,6 @@ def create_app() -> FastAPI:
     templates.env.filters["humanize_hz"] = humanize_hz
     if _STATIC_DIR.is_dir():
         app.mount("/static", StaticFiles(directory=str(_STATIC_DIR)), name="static")
-    # Serve the netboot-pc bake artifacts (vmlinuz + initrd + squashfs)
-    # under ``/boot/pixie-live-env/`` so the live-env iPXE chain can
-    # fetch them. Mounted UNCONDITIONALLY with ``check_dir=False``: on a
-    # fresh deploy the dir doesn't exist at startup (the operator stages
-    # it later via "Fetch live env"), and StaticFiles resolves each
-    # request against the directory live -- so a post-startup fetch is
-    # served without a pixie restart. Guarding the mount on ``is_dir()``
-    # at startup was a bug: the renderer would emit a plan pointing at
-    # ``/boot/pixie-live-env/vmlinuz`` that then 404'd until a restart.
-    if app.state.live_env_dir is not None:
-        # Create the dir so StaticFiles serves a clean 404 for a
-        # not-yet-staged file (an empty/absent dir would otherwise raise
-        # at request time) and picks up a later "Fetch live env" with no
-        # restart. ``check_dir=False`` keeps app startup resilient if the
-        # mkdir is somehow refused.
-        with contextlib_suppress(OSError):
-            app.state.live_env_dir.mkdir(parents=True, exist_ok=True)
-        app.mount(
-            "/boot/pixie-live-env",
-            StaticFiles(directory=str(app.state.live_env_dir), check_dir=False),
-            name="live-env",
-        )
 
     # ---------- exception handlers -----------------------------------
 
@@ -1813,28 +1737,17 @@ def create_app() -> FastAPI:
                 overlays=overlays_store, machines=machines_store, catalog=catalog, nbd=nbd
             )
         )
-        # Live-env media state. ``pixie-tui`` / ``pixie-inventory`` /
-        # ``pixie-flash-*`` all need vmlinuz + initrd + live.squashfs
-        # staged under ``PIXIE_LIVE_ENV_DIR`` (defaults to
-        # ``<state>/live-env``). Surface the staged / missing signal
-        # + per-file byte counts so the operator can tell at a glance
-        # whether the pixie boot modes are live or would fall back to
-        # the "unavailable" plan.
-        live_env_dir = request.app.state.live_env_dir
-        live_env_ready = False
-        live_env_files: dict[str, int | None] = {
-            "vmlinuz": None,
-            "initrd": None,
-            "live.squashfs": None,
-        }
-        if live_env_dir is not None:
-            for name in live_env_files:
-                p = live_env_dir / name
-                try:
-                    live_env_files[name] = p.stat().st_size if p.is_file() else None
-                except OSError:
-                    live_env_files[name] = None
-            live_env_ready = all(v is not None for v in live_env_files.values())
+        # Live-env readiness. ``pixie-tui`` / ``pixie-inventory`` /
+        # ``pixie-flash-*`` boot the disk image named by
+        # ``live_env.image_sha`` (PIXIE_LIVE_ENV_IMAGE_SHA / the Live env
+        # page) over ephemeral nbdboot. Ready == a sha is selected AND
+        # its catalog image is fetched on disk; otherwise those modes
+        # degrade to the "unavailable" plan. The renderer does the full
+        # bundle+blob check at boot; this is the at-a-glance signal.
+        live_env_image_sha = request.app.state.settings_store.resolve_live_env_image_sha()
+        live_env_ready = bool(live_env_image_sha) and any(
+            e.content_sha256 == live_env_image_sha for e in images if e.content_sha256
+        )
         # Events summary: total row count + unacknowledged error
         # count + newest ts. ``events_ack_ts`` is a soft cursor an
         # operator advances by hitting Acknowledge on the dashboard;
@@ -1870,10 +1783,7 @@ def create_app() -> FastAPI:
             "events_last_ts": events_stats["last_ts"],
             "events_ack_ts": events_ack_ts,
             "live_env_ready": live_env_ready,
-            "live_env_dir": str(live_env_dir) if live_env_dir is not None else "",
-            "live_env_files": live_env_files,
-            "live_env_src": request.app.state.settings_store.resolve_live_env_src(),
-            "live_env_fetch_state": dict(request.app.state.live_env_fetch_state),
+            "live_env_image_sha": live_env_image_sha,
         }
 
     @app.get("/ui/dashboard-live.json")
@@ -2529,35 +2439,15 @@ def create_app() -> FastAPI:
         return RedirectResponse(url="/ui/settings", status_code=status.HTTP_303_SEE_OTHER)
 
     def _live_env_context(request: Request, flash_error: str | None = None) -> dict[str, Any]:
-        """Render context for the dedicated /ui/live-env pane: staged
-        media state (ready + per-file sizes), the fetch source + extra
-        cmdline overrides (with provenance), and any in-flight fetch."""
+        """Render context for the dedicated /ui/live-env pane: the
+        selected live-env disk image (nbdboot), plus the extra-cmdline
+        override, each with provenance."""
         state = request.app.state
         store: SettingsStore = state.settings_store
-        live_env_dir = state.live_env_dir
-        files: dict[str, int | None] = {"vmlinuz": None, "initrd": None, "live.squashfs": None}
-        if live_env_dir is not None:
-            for name in files:
-                p = live_env_dir / name
-                try:
-                    files[name] = p.stat().st_size if p.is_file() else None
-                except OSError:
-                    files[name] = None
         return {
             "version": pixie.__version__,
             "authed": True,
             "page": "live-env",
-            "live_env_ready": all(v is not None for v in files.values()),
-            "live_env_dir": str(live_env_dir) if live_env_dir is not None else "",
-            "live_env_files": files,
-            "live_env_fetch_state": dict(state.live_env_fetch_state),
-            "live_env_src": {
-                "override": store.get(KEY_LIVE_ENV_SRC) or "",
-                "effective": store.resolve_live_env_src(),
-                "default": DEFAULT_LIVE_ENV_SRC,
-                "env": "PIXIE_LIVE_ENV_SRC",
-                "updated_at": store.updated_at(KEY_LIVE_ENV_SRC) or "",
-            },
             "live_env_extra_cmdline": {
                 "override": store.get(KEY_LIVE_ENV_EXTRA_CMDLINE) or "",
                 "effective": store.resolve_live_env_extra_cmdline(),
@@ -2615,23 +2505,6 @@ def create_app() -> FastAPI:
             store.clear(KEY_LIVE_ENV_EXTRA_CMDLINE)
         return RedirectResponse(url="/ui/live-env", status_code=status.HTTP_303_SEE_OTHER)
 
-    @app.post("/ui/live-env/src/edit", response_model=None)
-    def ui_live_env_src_edit(
-        request: Request,
-        live_env_src: str = Form(""),
-        _auth: None = Depends(_require_ui_auth),
-    ) -> RedirectResponse:
-        """Persist the live-env fetch-src override. Blank clears it so
-        the value falls back to $PIXIE_LIVE_ENV_SRC then the default
-        GitHub-release URL."""
-        store: SettingsStore = request.app.state.settings_store
-        raw = (live_env_src or "").strip()
-        if raw:
-            store.set_value(KEY_LIVE_ENV_SRC, raw)
-        else:
-            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,
@@ -2640,12 +2513,12 @@ def create_app() -> FastAPI:
     ) -> 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."""
+        nbdboot this image ephemerally. Blank clears the override so the
+        value falls back to $PIXIE_LIVE_ENV_IMAGE_SHA then empty, in
+        which case the live-env boot modes degrade to the unavailable
+        plan. 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
@@ -2669,69 +2542,6 @@ def create_app() -> FastAPI:
             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,
-        _auth: None = Depends(_require_ui_auth),
-    ) -> RedirectResponse:
-        """Download the live-env tarball (from PIXIE_LIVE_ENV_SRC or its
-        override) and stage vmlinuz + initrd + live.squashfs under
-        PIXIE_LIVE_ENV_DIR, on the fetch pool. The in-app replacement
-        for a manual ``make build VARIANT=netboot-pc`` + copy. Progress
-        lands on ``app.state.live_env_fetch_state`` for the dashboard to
-        poll; idempotent while a fetch is already running."""
-        state = request.app.state
-        live_env_dir = state.live_env_dir
-        fs = state.live_env_fetch_state
-        if live_env_dir is None:
-            fs.clear()
-            fs.update(
-                {
-                    "state": "error",
-                    "error": "no live-env dir (PIXIE_LIVE_ENV_DIR unset or unwritable)",
-                    "at_iso": _now_iso(),
-                }
-            )
-            return RedirectResponse(url="/ui/live-env", status_code=status.HTTP_303_SEE_OTHER)
-        if fs.get("state") == "fetching":
-            return RedirectResponse(url="/ui/live-env", status_code=status.HTTP_303_SEE_OTHER)
-
-        src = state.settings_store.resolve_live_env_src()
-        fs.clear()
-        fs.update({"state": "fetching", "src": src, "phase": "starting", "at_iso": _now_iso()})
-        events = getattr(state, "events_log", None)
-
-        def _run() -> None:
-            from pixie.catalog._live_env import stage_live_env
-
-            def _report(payload: dict[str, Any]) -> None:
-                # Layer phase / byte counters onto the "fetching" pill.
-                fs.update(payload)
-
-            try:
-                result = stage_live_env(src, live_env_dir, progress=_report)
-            except Exception as exc:
-                fs.clear()
-                fs.update({"state": "error", "src": src, "error": str(exc), "at_iso": _now_iso()})
-                if events is not None:
-                    events.emit(
-                        LIVE_ENV_FETCH_FAILED,
-                        summary=f"live-env fetch failed: {exc}",
-                        details={"src": src, "error": str(exc)},
-                    )
-                return
-            fs.clear()
-            fs.update({"state": "done", "src": src, "sha256": result.sha256, "at_iso": _now_iso()})
-            if events is not None:
-                events.emit(
-                    LIVE_ENV_FETCH_DONE,
-                    summary=f"live-env staged from {src} (sha {result.sha256[:12]})",
-                    details={"src": src, "sha256": result.sha256, "bytes": result.size},
-                )
-
-        state.fetch_pool.submit(_run)
-        return RedirectResponse(url="/ui/live-env", status_code=status.HTTP_303_SEE_OTHER)
-
     # ---------- feature routers --------------------------------------
     #
     # Catalog + blob + artifacts routes live at the same URL shape they

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixie-lab
-Version: 0.4.2
+Version: 0.4.3
 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.2.dist-info → pixie_lab-0.4.3.dist-info}/RECORD

@@ -9,7 +9,6 @@ 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=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
@@ -18,7 +17,7 @@ pixie/deploy/__init__.py,sha256=3PvSvrIRdqxLCz0nTdVSBiPzEtDl359XSUBgyMBkMT8,1019
 pixie/deploy/_main.py,sha256=Or2espz9oWNmnGfyEzIsEyvRwWEHL4uxyE6U9OdMZJs,15403
 pixie/deploy/_templates.py,sha256=WkkKRDU00FDWVZM0XeKR-BCtSBPvaZ2QHM1TBeq0RYg,5418
 pixie/events/__init__.py,sha256=3Quxl56ePkKD9-PjbomCOOZOpmqJ3wHcYa7VcT9KXv8,923
-pixie/events/_kinds.py,sha256=clGaTjEmbX13FibWiXREMb2WkYQpUio4lQpvHr8iLTM,10957
+pixie/events/_kinds.py,sha256=LyyIrg4pGaat062sBIFrfGYGbZflsenfq7P-PkWhP04,10160
 pixie/events/_log.py,sha256=0XSdIYrPIEtmxjTq9L7gy1Q4qGotTxgHhMkM9fv8tyY,9041
 pixie/events/_routes.py,sha256=MbY69aZKDEzy4O8AizHtv_POPbdNMqz94imccFbtelM,1363
 pixie/exports/__init__.py,sha256=RiI69GG_bjkb_d1CNRyk9KI7wyMpLVvWc_NgNnWxOYc,546
@@ -31,7 +30,7 @@ pixie/machines/_store.py,sha256=zh89zj2s5CurMFO258i10ANW20VCTQk0kT8MgRhnWi0,3037
 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=Tg2oMZQ_vSkEmsc2Rn_SXZ6Ed14LXUmZTOgzkLQC56g,18833
+pixie/pxe/_renderer.py,sha256=KU9M0eZ5aRxI9Tsyej9MMXkBt5TooRoKY-a7pSQHvR8,17277
 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
@@ -45,9 +44,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=TrhjRN2ME1K3VsgJPJif7ZA3Tf7pM9k9oL57Hhh_YH0,12409
+pixie/web/_settings_store.py,sha256=X9dO5dr31PvRUM-Y7cLilEiNG_7MCV8CpDW2Nc6V0Tc,11242
 pixie/web/_table_state.py,sha256=zGH5oZ-XlMqUFQqmYglYqT_fu1Yrtaw-g5yhPtAKAEc,9524
-pixie/web/main.py,sha256=1eu183QjBjcN5yKuFn0TGD5rNaDuF6U4TPED29EsSJ0,117004
+pixie/web/main.py,sha256=r4ZmVBBjvj5Cs8nWOOHZkBVv2BttNeNOSnKc_fNb-1Q,108149
 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
@@ -58,12 +57,12 @@ pixie/web/_static/fonts/bootstrap-icons.woff,sha256=9VUTt7WRy4SjuH_w406iTUgx1v7c
 pixie/web/_static/fonts/bootstrap-icons.woff2,sha256=bHVxA2ShylYEJncW9tKJl7JjGf2weM8R4LQqtm_y6mE,134044
 pixie/web/_templates/catalog.html,sha256=CfjO7qcoy5226qy-24Qkx-ZvpoeRtW5gWsTkQzhi8sg,17465
 pixie/web/_templates/catalog_detail.html,sha256=G12HHq2iYKv5bn5wjGfppUPJ12iOm9G5TjDlr-DTsHc,18182
-pixie/web/_templates/dashboard.html,sha256=-77IP9kd1Mr9IVwp7aJMwEmuTL1jjlC8b0RyxDKOvJA,16051
+pixie/web/_templates/dashboard.html,sha256=Ys3TBRpQF9PShMa2uFtTIKSWeAc6THF6JDRHaIXgOGA,14996
 pixie/web/_templates/events.html,sha256=ifawe--m5FMcicKZ2daCCycV7rGgpLJz7A309UrTolM,7666
 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=0goOWgrCXvONHEyZSGfqG6h_B0rPaEHvw7Cbt-UpL4I,11557
+pixie/web/_templates/live_env.html,sha256=EtZB728ZG-v2kG-YAwox3R9moz0O24rBD_HGJXkpRQM,7132
 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
@@ -75,10 +74,9 @@ pixie/web/_templates/_partials/table_helpers.html,sha256=xObkXvfOSoM9rB5Ni_W3nnU
 pixie/web/_templates/ipxe/bootstrap.j2,sha256=xt13H2dHf-SeLhWRQvptqGY51sJ_L24C2ExnLj9uXPc,490
 pixie/web/_templates/ipxe/exit.j2,sha256=pbTXTwjgiEsPZlRuv7_J0Q3BepXEqXnb82mv1sxDW24,371
 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.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,,
+pixie_lab-0.4.3.dist-info/METADATA,sha256=5vQcLth91856S2hyQf638LF20qcMfqksG7kk_vHkRvU,4452
+pixie_lab-0.4.3.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+pixie_lab-0.4.3.dist-info/entry_points.txt,sha256=G3vtKpg_gQtisiyS31EjdvC4QC52Kfw2K7iMsfsnj5A,71
+pixie_lab-0.4.3.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+pixie_lab-0.4.3.dist-info/RECORD,,

pixie/catalog/_live_env.py

@@ -1,128 +0,0 @@
-"""Fetch + stage the pixie live-env (the netboot-pc bake).
-
-The live env -- ``vmlinuz`` + ``initrd`` + ``live.squashfs`` that the
-``pixie-flash-*`` / ``pixie-inventory`` / ``pixie-tui`` boot modes chain
-into -- was the one artifact pixie could not retrieve itself: it had to
-be baked locally (``make build VARIANT=netboot-pc``) or hand-copied into
-``PIXIE_LIVE_ENV_DIR``. This module pulls it from a single tarball
-``src`` (the same ``https://`` / ``oras://`` schemes the catalog fetch
-speaks) and stages the three files atomically, reusing the catalog
-fetch pipeline's curl download + resume plumbing.
-
-Contract with CI's ``publish-release`` job: the tarball carries exactly
-``vmlinuz`` + ``initrd`` + ``live.squashfs`` at the archive root. Any
-other member is ignored; a missing one is a hard error (better a loud
-"tarball is wrong" than a live env that half-stages and boots into a
-mysterious squashfs-fetch hang).
-"""
-
-from __future__ import annotations
-
-import os
-import shutil
-import tarfile
-import tempfile
-from dataclasses import dataclass, field
-from pathlib import Path
-
-from pixie._util import CHUNK
-from pixie.catalog._fetcher import (
-    FetchError,
-    ProgressReporter,
-    _resolve_fetch_url,
-    _stream_to_tmpfile,
-)
-
-# The three files a target's iPXE chain pulls from
-# ``/boot/pixie-live-env/``. Names match what ``pixie-live-env.j2``
-# references (note ``live.squashfs``, not the bake's raw ``*.squashfs``
-# -- the CI tar step renames it).
-LIVE_ENV_FILES: frozenset[str] = frozenset({"vmlinuz", "initrd", "live.squashfs"})
-
-
-@dataclass
-class LiveEnvResult:
-    """Outcome of a successful stage: the src it came from, the sha256
-    of the downloaded tarball, its byte size, and the staged file
-    sizes."""
-
-    src: str
-    sha256: str
-    size: int
-    files: dict[str, int] = field(default_factory=dict)
-
-
-def _unpack_live_env_tar(tar_path: Path, live_env_dir: Path) -> dict[str, int]:
-    """Extract the live-env trio from ``tar_path`` into ``live_env_dir``
-    atomically. Returns ``{name: size_bytes}``.
-
-    Hardening mirrors :func:`pixie.catalog._fetcher._unpack_netboot_bundle`:
-    only basenames in :data:`LIVE_ENV_FILES` at the archive root are
-    accepted; nested paths, parent traversal, and dotfiles are dropped.
-    Files land in a staging subdir first, then each is ``os.replace``'d
-    onto its final name so a target fetching mid-stage sees the old
-    file or the new one, never a half-written squashfs.
-    """
-    live_env_dir.mkdir(parents=True, exist_ok=True)
-    staging = Path(tempfile.mkdtemp(prefix=".staging-", dir=str(live_env_dir)))
-    try:
-        # ``r:*`` transparently handles .tar / .tar.gz / .tar.xz so the
-        # CI side can pick whatever compression without a pixie change.
-        with tarfile.open(str(tar_path), mode="r:*") as tar:
-            for member in tar.getmembers():
-                if not member.isfile():
-                    continue
-                name = os.path.basename(member.name)
-                if not name or name.startswith(".") or name != member.name:
-                    continue
-                if name not in LIVE_ENV_FILES:
-                    continue
-                extracted = tar.extractfile(member)
-                if extracted is None:
-                    continue
-                with (staging / name).open("wb") as out:
-                    shutil.copyfileobj(extracted, out, length=CHUNK)
-
-        missing = LIVE_ENV_FILES - {p.name for p in staging.iterdir()}
-        if missing:
-            raise FetchError(
-                f"live-env tarball {tar_path.name} missing required file(s): {sorted(missing)}"
-            )
-
-        sizes: dict[str, int] = {}
-        for name in sorted(LIVE_ENV_FILES):
-            final = live_env_dir / name
-            os.replace(staging / name, final)
-            sizes[name] = final.stat().st_size
-        return sizes
-    finally:
-        shutil.rmtree(staging, ignore_errors=True)
-
-
-def stage_live_env(
-    src: str,
-    live_env_dir: Path,
-    *,
-    progress: ProgressReporter = None,
-) -> LiveEnvResult:
-    """Download the live-env tarball at ``src`` and stage its three
-    files into ``live_env_dir``.
-
-    Reuses the catalog fetch's curl transport (resume + retry + stall
-    detection). The tarball lands in ``live_env_dir`` itself so the
-    unpack + ``os.replace`` stay on one filesystem. Raises
-    :class:`FetchError` on an empty/bad src, an unsupported scheme, a
-    download failure, or a tarball missing a required file.
-    """
-    if not (src or "").strip():
-        raise FetchError("no live-env src configured (set PIXIE_LIVE_ENV_SRC)")
-    url, headers = _resolve_fetch_url(src.strip())
-    live_env_dir.mkdir(parents=True, exist_ok=True)
-    tmp_tar, sha256, size = _stream_to_tmpfile(url, headers, live_env_dir, progress)
-    try:
-        if progress is not None:
-            progress({"phase": "unpacking"})
-        sizes = _unpack_live_env_tar(tmp_tar, live_env_dir)
-    finally:
-        tmp_tar.unlink(missing_ok=True)
-    return LiveEnvResult(src=src.strip(), sha256=sha256, size=size, files=sizes)

pixie/web/_templates/ipxe/pixie-live-env.j2

@@ -1,55 +0,0 @@
-#!ipxe
-# pixie plan for {{ mac }} - boot_mode={{ boot_mode }}
-#
-# Boot pixie's own live env. The netboot-pc bake produced vmlinuz +
-# initrd + squashfs artifacts; the pixie deploy staged them under
-# ``$PIXIE_LIVE_ENV_DIR`` and this HTTP process exposes them at
-# ``/boot/pixie-live-env/``. Debian live-boot cmdline shape:
-#
-#   boot=live components fetch=<squashfs URL>
-#
-# handles the initrd -> squashfs pivot. ``pixie.server`` +
-# ``pixie.mac`` are the two knobs pixie-on-tty1.service reads on
-# every live-env boot; the pixie CLI then GETs
-# ``<server>/pxe/<mac>/plan`` and dispatches (auto-flash,
-# inventory + reboot, interactive wizard, or exit).
-#
-# ``ip=dhcp`` mirrors the nbdboot template's cmdline: the initrd's
-# network module (Debian live-boot, in this case) needs an explicit
-# DHCP directive to bring the primary NIC up before pixie CLI tries
-# to reach ``$pixie-server``. ``console=`` chain matches nbdboot too
-# so a target with a serial console reads output on both tty0 and
-# ttyS0/1 -- most bench-side debugging happens on serial.
-
-set pixie-base http://{{ host }}:{{ port }}
-
-# Cmdline matches bty's proven-working live-env kernel line
-# (bty/src/bty/web/_templates/ipxe_flash.j2 + ipxe_tui.j2). Deltas
-# from an earlier pixie shape that had drifted:
-#
-# - ``ip=dhcp`` REMOVED. Debian live-boot's ``fetch=`` handler
-#   configures the network itself via its own DHCP client; keeping
-#   both racing produced silent hangs on GIGABYTE MC12-LE0 hardware
-#   where live-boot's ipconfig would return with no NIC configured
-#   despite iPXE having successfully DHCP'd from the same interface.
-#   bty never had it; verified live on 10.20.30.61 (matx-bmc) with
-#   nothing else changing.
-# - ``plymouth.enable=0 modprobe.blacklist=nouveau,rndis_host
-#   nouveau.modeset=0 systemd.gpt_auto=0`` ADDED. Same set bty
-#   ships. plymouth stays off so the operator sees the full boot
-#   stream (a wedge between two ``[ OK ] Started X`` lines is
-#   immediately diagnostic); nouveau blacklist keeps NVIDIA
-#   GPU quirks from stalling non-graphics targets; rndis_host
-#   blacklist stops the kernel from claiming a USB-console-emulated
-#   NIC before the real one appears; systemd.gpt_auto=0 keeps
-#   systemd from auto-mounting random GPT partitions the flasher
-#   is about to overwrite.
-#
-# ``console=`` chain matches bty too; LAST-wins for /dev/console.
-# The ttyS0 tail lands on most bench-side USB-serial adapters;
-# operators driving from a BMC's SoL on ttyS1 append their own
-# ``console=ttyS1,115200`` via PIXIE_LIVE_ENV_EXTRA_CMDLINE.
-
-kernel ${pixie-base}/boot/pixie-live-env/vmlinuz boot=live fetch=${pixie-base}/boot/pixie-live-env/live.squashfs components console=tty0 console=ttyS1,115200 console=ttyS0,115200 earlyprintk=ttyS0,115200 plymouth.enable=0 modprobe.blacklist=nouveau,rndis_host nouveau.modeset=0 systemd.gpt_auto=0 pixie.server=${pixie-base} pixie.mac={{ mac }} bty.server=${pixie-base} bty.mac={{ mac }}{% if extra_cmdline %} {{ extra_cmdline }}{% endif %}
-initrd ${pixie-base}/boot/pixie-live-env/initrd
-boot