From 133331844e3cfd88f236d2247e94f3e475eafac2 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 7 Aug 2026 20:09:09 +0000 Subject: [PATCH 1/4] feat(bootc-iso): resurrect bootc-installer ISO builder from #61 Restore the fisherman/bootc-installer live ISO builder merged in #61 and reverted in #66, additively under bootc-iso/ so the Anaconda/titanoboa system at the repo root is untouched. The LUKS E2E workflow returns as .github/workflows/test-luks-install-bootc.yml, workflow_dispatch-only, with the matrix trimmed to stable x {bluefin, bluefin-lts} and paths pointed at the bootc-iso/ subtree. bootc-iso/README.md documents the known blockers (ISO size/dedupe, vfs-vs-overlay, LTS dracut failure #63) and the intended single-copy composefs/erofs fix direction. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01KSjBPVDcnK71WveusaK7Nc --- .github/workflows/test-luks-install-bootc.yml | 196 +++++ bootc-iso/Containerfile | 104 +++ bootc-iso/Containerfile.builder | 28 + bootc-iso/HANDOFF.md | 172 ++++ bootc-iso/README.md | 59 ++ bootc-iso/bluefin-lts/payload_ref | 1 + bootc-iso/bluefin/payload_ref | 1 + bootc-iso/justfile | 777 ++++++++++++++++++ bootc-iso/scripts/configure_podman_storage.sh | 70 ++ bootc-iso/src/build-iso.sh | 184 +++++ bootc-iso/src/configure-live.sh | 361 ++++++++ .../95bluefin-isofile/bluefin-isofile.sh | 94 +++ .../dracut/95bluefin-isofile/module-setup.sh | 23 + bootc-iso/src/etc/bootc-installer/images.json | 16 + bootc-iso/src/etc/bootc-installer/recipe.json | 57 ++ bootc-iso/src/flatpaks | 45 + .../icons/hicolor/128x128/apps/bluefin.png | Bin 0 -> 4223 bytes .../src/icons/hicolor/16x16/apps/bluefin.png | Bin 0 -> 437 bytes .../src/icons/hicolor/24x24/apps/bluefin.png | Bin 0 -> 687 bytes .../icons/hicolor/256x256/apps/bluefin.png | Bin 0 -> 8966 bytes .../src/icons/hicolor/32x32/apps/bluefin.png | Bin 0 -> 946 bytes .../src/icons/hicolor/48x48/apps/bluefin.png | Bin 0 -> 1508 bytes .../icons/hicolor/512x512/apps/bluefin.png | Bin 0 -> 19212 bytes .../src/icons/hicolor/64x64/apps/bluefin.png | Bin 0 -> 2071 bytes bootc-iso/src/images/bluefin.png | Bin 0 -> 19212 bytes bootc-iso/src/images/bluefin.svg | 1 + bootc-iso/src/install-flatpaks.sh | 106 +++ bootc-iso/src/luks-unlock.py | 534 ++++++++++++ bootc-iso/src/show-screenshot.sh | 32 + 29 files changed, 2861 insertions(+) create mode 100644 .github/workflows/test-luks-install-bootc.yml create mode 100644 bootc-iso/Containerfile create mode 100644 bootc-iso/Containerfile.builder create mode 100644 bootc-iso/HANDOFF.md create mode 100644 bootc-iso/README.md create mode 100644 bootc-iso/bluefin-lts/payload_ref create mode 100644 bootc-iso/bluefin/payload_ref create mode 100644 bootc-iso/justfile create mode 100755 bootc-iso/scripts/configure_podman_storage.sh create mode 100644 bootc-iso/src/build-iso.sh create mode 100644 bootc-iso/src/configure-live.sh create mode 100644 bootc-iso/src/dracut/95bluefin-isofile/bluefin-isofile.sh create mode 100644 bootc-iso/src/dracut/95bluefin-isofile/module-setup.sh create mode 100644 bootc-iso/src/etc/bootc-installer/images.json create mode 100644 bootc-iso/src/etc/bootc-installer/recipe.json create mode 100644 bootc-iso/src/flatpaks create mode 100644 bootc-iso/src/icons/hicolor/128x128/apps/bluefin.png create mode 100644 bootc-iso/src/icons/hicolor/16x16/apps/bluefin.png create mode 100644 bootc-iso/src/icons/hicolor/24x24/apps/bluefin.png create mode 100644 bootc-iso/src/icons/hicolor/256x256/apps/bluefin.png create mode 100644 bootc-iso/src/icons/hicolor/32x32/apps/bluefin.png create mode 100644 bootc-iso/src/icons/hicolor/48x48/apps/bluefin.png create mode 100644 bootc-iso/src/icons/hicolor/512x512/apps/bluefin.png create mode 100644 bootc-iso/src/icons/hicolor/64x64/apps/bluefin.png create mode 100644 bootc-iso/src/images/bluefin.png create mode 100644 bootc-iso/src/images/bluefin.svg create mode 100755 bootc-iso/src/install-flatpaks.sh create mode 100644 bootc-iso/src/luks-unlock.py create mode 100755 bootc-iso/src/show-screenshot.sh diff --git a/.github/workflows/test-luks-install-bootc.yml b/.github/workflows/test-luks-install-bootc.yml new file mode 100644 index 0000000..49312cd --- /dev/null +++ b/.github/workflows/test-luks-install-bootc.yml @@ -0,0 +1,196 @@ +name: LUKS Install End-to-End Test (bootc-iso, experimental) + +# Experimental resurrection of the bootc-installer ISO builder from PR #61 +# (reverted in #66). Lives entirely under bootc-iso/ and is dispatch-only — +# it must never run on pull_request or a schedule. +on: + workflow_dispatch: + +permissions: + issues: write + pull-requests: write + contents: write + actions: read + +jobs: + luks-e2e: + name: LUKS E2E (${{ matrix.target }}, ${{ matrix.installer_channel }}) + runs-on: ubuntu-24.04 + timeout-minutes: 90 + strategy: + fail-fast: false + matrix: + installer_channel: [stable] + target: [bluefin, bluefin-lts] + defaults: + run: + working-directory: bootc-iso + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Ensure screenshots branch exists + continue-on-error: true + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + REPO: ${{ github.repository }} + run: | + if gh api "/repos/${REPO}/git/refs/heads/ci-screenshots" &>/dev/null; then + echo "ci-screenshots branch already exists" + else + echo "Creating ci-screenshots branch..." + DEFAULT=$(gh api "/repos/${REPO}" --jq '.default_branch') + SHA=$(gh api "/repos/${REPO}/git/refs/heads/${DEFAULT}" --jq '.object.sha') + gh api --method POST "/repos/${REPO}/git/refs" \ + -f "ref=refs/heads/ci-screenshots" \ + -f "sha=${SHA}" + echo "ci-screenshots branch created from ${DEFAULT}" + fi + + - name: Free disk space + uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be + with: + tool-cache: true + + - name: Install dependencies + run: | + sudo apt-get update -qq + sudo apt-get install -y \ + just podman buildah mtools xorriso \ + qemu-system-x86 ovmf socat sshpass \ + imagemagick -qq + + - name: Log in to GHCR + run: | + echo "${{ secrets.GITHUB_TOKEN }}" | \ + sudo podman login ghcr.io -u ${{ github.actor }} --password-stdin + + - name: Configure podman storage (intelligent driver selection) + run: bash scripts/configure_podman_storage.sh + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: '1.23' + + - name: Clone patched fisherman + run: | + git clone https://github.com/projectbluefin/fisherman.git \ + --branch fix/overlay-driver-for-ostree-bootc-install \ + --depth 1 \ + /tmp/fisherman + + - name: Build debug ISO + id: build + run: | + START=$(date +%s) + sudo mkdir -p /var/iso-build + sudo $(command -v just) debug=1 installer_channel=${{ matrix.installer_channel }} output_dir=/var/iso-build iso-sd-boot ${{ matrix.target }} + mkdir -p output + sudo cp /var/iso-build/*.iso output/ 2>/dev/null || true + sudo chown -R "$USER:$(id -gn)" output/ + echo "duration=$(( $(date +%s) - START ))" >> "$GITHUB_OUTPUT" + ISO=$(ls output/*.iso 2>/dev/null | head -1) + echo "iso_size=$(stat -c%s "$ISO" 2>/dev/null || echo 0)" >> "$GITHUB_OUTPUT" + + - name: Fix output directory ownership + run: sudo chown -R "$USER:$(id -gn)" output/ 2>/dev/null || true + + - name: Run LUKS end-to-end test + id: luks_test + env: + FISHER_REPO: /tmp/fisherman/fisherman + run: | + START=$(date +%s) + just luks-test-qemu ${{ matrix.target }} + echo "duration=$(( $(date +%s) - START ))" >> "$GITHUB_OUTPUT" + continue-on-error: true + + - name: Convert and publish screenshots + if: always() + continue-on-error: true + id: screenshots + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + REPO: ${{ github.repository }} + RUN_ID: ${{ github.run_id }} + run: | + sudo chmod a+r /tmp/luks-screenshot-*.ppm /tmp/luks-unlock-snap.ppm 2>/dev/null || true + + commit_png() { + local src_ppm="$1" label="$2" out_var="$3" + local png="/tmp/${label}.png" + + convert "$src_ppm" "$png" 2>/dev/null || return 0 + [[ -f "$png" ]] || return 0 + + local path_in_repo="luks-e2e/${RUN_ID}/${{ matrix.target }}/${{ matrix.installer_channel }}/${label}.png" + local existing_sha + existing_sha=$(gh api "/repos/${REPO}/contents/${path_in_repo}?ref=ci-screenshots" \ + --jq '.sha' 2>/dev/null || echo "") + + local b64_file + b64_file=$(mktemp) + base64 -w0 "$png" > "$b64_file" + + jq -n \ + --arg msg "LUKS E2E screenshot: ${label} (run ${RUN_ID})" \ + --rawfile content "$b64_file" \ + --arg branch "ci-screenshots" \ + --arg sha "$existing_sha" \ + 'if $sha != "" then + {message: $msg, content: ($content | rtrimstr("\n")), branch: $branch, sha: $sha} + else + {message: $msg, content: ($content | rtrimstr("\n")), branch: $branch} + end' | \ + gh api --method PUT "/repos/${REPO}/contents/${path_in_repo}" --input - > /dev/null + + rm "$b64_file" + local url="https://raw.githubusercontent.com/${REPO}/ci-screenshots/${path_in_repo}" + echo "${out_var}=${url}" >> "$GITHUB_OUTPUT" + echo "Published ${label} → ${url}" + } + + commit_png /tmp/luks-screenshot-live.ppm "live-boot" "live_url" + commit_png /tmp/luks-screenshot-plymouth.ppm "plymouth" "plymouth_url" + commit_png /tmp/luks-screenshot-final.ppm "final-boot" "final_url" + + - name: Write job summary + if: always() + run: | + RESULT="${{ steps.luks_test.outcome }}" + CHANNEL="${{ matrix.installer_channel }}" + TARGET="${{ matrix.target }}" + ICON=$( [ "$RESULT" = "success" ] && echo "PASS" || echo "FAIL" ) + { + echo "## ${ICON} LUKS End-to-End Test (${TARGET}, ${CHANNEL}) — ${RESULT}" + echo "" + echo "| Step | Value |" + echo "|------|-------|" + echo "| ISO size | $(numfmt --to=iec ${{ steps.build.outputs.iso_size }} 2>/dev/null || echo N/A) |" + echo "| Build time | ${{ steps.build.outputs.duration }}s |" + echo "| LUKS test time | ${{ steps.luks_test.outputs.duration }}s |" + } >> "$GITHUB_STEP_SUMMARY" + + - name: Upload serial logs + if: always() + run: | + sudo chmod a+r /tmp/bluefin-qemu-*.log 2>/dev/null || true + + - name: Upload serial logs artifact + if: always() + uses: actions/upload-artifact@v4 + with: + name: luks-e2e-serial-logs-${{ matrix.target }}-${{ matrix.installer_channel }} + path: | + /tmp/bluefin-qemu-live-serial.log + /tmp/bluefin-qemu-installed-serial.log + if-no-files-found: warn + retention-days: 14 + + - name: Fail if LUKS test failed + if: steps.luks_test.outcome == 'failure' + run: | + echo "::error::LUKS end-to-end test failed — see serial logs and screenshots above" + exit 1 diff --git a/bootc-iso/Containerfile b/bootc-iso/Containerfile new file mode 100644 index 0000000..9c16be8 --- /dev/null +++ b/bootc-iso/Containerfile @@ -0,0 +1,104 @@ +# Bluefin live ISO installer image +# +# Build with: +# just container bluefin +# +# Three-stage build: +# 1. bluefin-ref — original Bluefin image (provides kernel modules) +# 2. initramfs-builder — Debian: builds a dmsquash-live initramfs against +# Bluefin's kernel modules in its native glibc environment +# 3. final — Bluefin: receives the rebuilt initramfs + live-env setup +# +# Bluefin is Fedora/ostree-based using GRUB2 for the installed system. +# The live ISO uses systemd-boot for ESP boot (installed in the final stage). +# The installed system's bootloader is controlled by fisherman/bootc-installer +# via images.json (grub2). +# +# The initramfs is built in a separate Debian stage so no cross-distro binary +# grafting is needed; only the initramfs.img output crosses the stage boundary. + +# Base image — override to build bluefin-lts or other variants. +# Example: podman build --build-arg BASE_IMAGE=ghcr.io/ublue-os/bluefin-lts:latest ... +ARG BASE_IMAGE=ghcr.io/ublue-os/bluefin:stable + +# ── Stage 1: Bluefin reference (kernel modules source) ─────────────────────── +FROM ${BASE_IMAGE} AS bluefin-ref + +# ── Stage 2: Debian — builds the dmsquash-live initramfs ───────────────────── +# Dracut runs natively in Debian against Bluefin's kernel modules. +# Only /tmp/initramfs.img crosses into the final stage. +FROM debian:sid AS initramfs-builder + +RUN apt-get update && \ + DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \ + dracut \ + dmsetup \ + && rm -rf /var/lib/apt/lists/* + +# Import Bluefin's kernel module tree so dracut targets the correct kernel +COPY --from=bluefin-ref /usr/lib/modules /usr/lib/modules + +# Add Bluefin-specific initramfs support for Ventoy/file-backed ISO boot. +COPY src/dracut/95bluefin-isofile /usr/lib/dracut/modules.d/95bluefin-isofile + +RUN set -ex; \ + kernel=$(ls /usr/lib/modules | sort -V | tail -1); \ + echo "Building dmsquash-live initramfs for kernel ${kernel}"; \ + # Check which optional drivers are available (el10 kernel may lack ntfs3). + NTFS3=""; test -f "/usr/lib/modules/${kernel}/kernel/fs/ntfs3/ntfs3.ko" && NTFS3="ntfs3"; \ + DRACUT_NO_XATTR=1 dracut -v --force --zstd --reproducible --no-hostonly \ + --add "dmsquash-live bluefin-isofile" \ + --add-drivers "squashfs overlay loop iso9660 sr_mod cdrom sd_mod usb-storage xhci-pci exfat vfat fat ${NTFS3} ext4" \ + /tmp/initramfs.img "${kernel}"; \ + ls -lh /tmp/initramfs.img + +# ── Stage 3: Final Bluefin live image ──────────────────────────────────────── +ARG BASE_IMAGE +FROM ${BASE_IMAGE} + +# Set to "dev" to pull the tuna-installer dev build (continuous-dev release) +# instead of the stable continuous build. +ARG INSTALLER_CHANNEL=stable +ENV INSTALLER_CHANNEL=${INSTALLER_CHANNEL} + +# DEBUG=1 builds a debug ISO (installer only, SSH enabled). +ARG DEBUG=0 +ENV DEBUG=${DEBUG} + +# Filesystem for the installed system: btrfs (Bluefin stable) or xfs (Bluefin LTS). +# Override via: --build-arg FILESYSTEM=xfs +ARG FILESYSTEM=btrfs + +# Install systemd-boot for the live ISO ESP (Bluefin ships GRUB2 for the +# installed system, but the live ISO needs a UEFI bootloader on the ESP image). +# systemd-boot-unsigned is the Fedora package; use rpm-ostree to layer it. +# fuse-overlayfs provides overlay-on-overlay for kernels without native support +# (e.g. CentOS Stream 10 in bluefin-lts — containers/storage needs it on +# overlayfs-based rootfs). +RUN rpm-ostree install --apply-live --allow-inactive systemd-boot-unsigned fuse-overlayfs \ + && rm -rf /var/cache/rpm-ostree + +# Replace the OCI-mode initramfs with the dmsquash-live initramfs from stage 2 +COPY --from=initramfs-builder /tmp/initramfs.img /tmp/initramfs.img +RUN kernel=$(ls /usr/lib/modules | sort -V | tail -1) && \ + mv /tmp/initramfs.img "/usr/lib/modules/${kernel}/initramfs.img" && \ + echo "Replaced initramfs for kernel ${kernel}" + +# ── Flatpak install layer ───────────────────────────────────────────────────── +COPY src/flatpaks /tmp/flatpaks-list +RUN --mount=type=bind,source=src,target=/src \ + --mount=type=cache,target=/var/cache/flatpak-dl,id=bluefin-flatpak \ + /src/install-flatpaks.sh + +# ── Live-environment configure layer ───────────────────────────────────────── +COPY src/ /tmp/src/ +RUN chmod +x /tmp/src/configure-live.sh && /tmp/src/configure-live.sh + +ARG BASE_IMAGE +ARG FILESYSTEM +# Patch installer configs to reference the actual base image + filesystem for this variant. +RUN sed -i "s|ghcr.io/ublue-os/bluefin:stable|${BASE_IMAGE}|g" \ + /etc/bootc-installer/images.json \ + /etc/bootc-installer/recipe.json && \ + sed -i 's|"filesystem": "btrfs"|"filesystem": "${FILESYSTEM}"|g' \ + /etc/bootc-installer/images.json diff --git a/bootc-iso/Containerfile.builder b/bootc-iso/Containerfile.builder new file mode 100644 index 0000000..161d701 --- /dev/null +++ b/bootc-iso/Containerfile.builder @@ -0,0 +1,28 @@ +# ISO assembly builder image (Debian-based) +# +# Used by: just iso-sd-boot +# +# This container has all the tools needed to assemble a UEFI live ISO: +# xorriso — ISO-9660 creation with El Torito EFI boot entry +# mksquashfs — compress the live rootfs into a squashfs image +# mkfs.fat — create the FAT ESP image for systemd-boot +# mtools — populate the FAT image without requiring a loop mount +# implantisomd5 — embed MD5 checksum for ISO integrity verification +# +# All tools run in their native Debian environment; no cross-distro binary +# grafting required. +FROM debian:sid + +RUN apt-get update && \ + DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \ + xorriso \ + isomd5sum \ + squashfs-tools \ + dosfstools \ + mtools \ + && rm -rf /var/lib/apt/lists/* + +COPY src/build-iso.sh /build-iso.sh +RUN chmod +x /build-iso.sh + +ENTRYPOINT ["/build-iso.sh"] diff --git a/bootc-iso/HANDOFF.md b/bootc-iso/HANDOFF.md new file mode 100644 index 0000000..283449a --- /dev/null +++ b/bootc-iso/HANDOFF.md @@ -0,0 +1,172 @@ +# Bluefin bootc-ISO — Handoff + +This document captures the current state of the Bluefin bootc-ISO effort for +another agent or maintainer to pick up, including the architectural differences +from dakota-iso (which works) and the remaining blocker. + +## What this branch does + +PR #61 (`feat/bluefin-bootc-iso`) adds a full ISO builder for Bluefin and +Bluefin LTS using the bootc-installer Flatpak (fisherman) with an ostree +backend. The ISO is live-bootable, supports LUKS-encrypted installation via +fisherman, and is built in CI via GitHub Actions. + +Dakota-ISO exists as a working reference: same toolchain (fisherman, +bootc-installer), same VM-based LUKS E2E test, same QEMU/KVM harness. +The differences are the root cause of the remaining issues. + +## Architectural comparison: bluefin-iso vs dakota-iso + +### 1. Image backend (UNCHANGEABLE) + +| Aspect | Dakota-ISO | Bluefin-ISO | +|--------|------------|-------------| +| Base image | `ghcr.io/projectbluefin/dakota:latest` | `ghcr.io/ublue-os/bluefin:stable` / `...bluefin:lts` | +| Backend | composefs-native | ostree | +| Installed bootloader | systemd-boot | GRUB2 | +| `images.json` `composefs` | `true` | absent | +| `images.json` `needs_user_creation` | `false` | `true` | +| Filesystem | btrfs | btrfs (bluefin), xfs (bluefin-lts) | + +Bluefin IS ostree — this cannot change. All the memory and deployment +differences flow from this. + +### 2. Install flow (CURRENT / TRIED) + +Dakota uses `"image": "containers-storage:..."` in the fisherman recipe with +`composeFsBackend: true`. Fisherman's composefs path: +1. Exports the image to an OCI layout via skopeo +2. Runs `podman --root --storage-driver overlay --tmpfs /var/tmp ... oci: bootc install --composefs-backend ...` +3. Works reliably at 8 GB VM RAM + +Bluefin has tried several approaches: + +| Approach | Result | Why | +|----------|--------|-----| +| `containers-storage:` recipe + VFS (original) | OOM | VFS copies every layer | +| Registry pull + VFS (be4f757) | OOM | Same VFS issue | +| Registry + overlay redirect + OCI layout (1b70f55..266b4fb) | OOM at podman run | Podman container setup ate 14.9 GB virtual | +| Empty image → bootcDirect (58c8ed2) | `bootc install` fails | Needs `--source-imgref` | +| bootcDirect + `--source-imgref docker://` (625ab3b) | untested | Would require network pull (offline VM) | +| bootcDirect + `--source-imgref containers-storage:` (24d15db) | **PENDING CI** | Most promising — no podman, no network | + +### 3. Justfile recipe differences (luks-install-qemu) + +```json +// Dakota recipe (WORKS): +{"image": "containers-storage:ghcr.io/projectbluefin/dakota:latest", + "composeFsBackend": true, + "bootloader": "systemd"} + +// Bluefin recipe (CURRENT — awaiting CI): +{"image": "", + "targetImgref": "ghcr.io/ublue-os/bluefin:stable", + "composeFsBackend": false, + "bootloader": "grub2"} +``` + +### 4. QEMU VM RAM + +| | Dakota | Bluefin (currently) | +|---|---|---| +| Live ISO QEMU | 8 GB | 8 GB (was bumped to 12 GB, reverted) | +| Installed disk QEMU | 8 GB | 8 GB | +| Second disk (cs-disk) | No | Removed | + +Dakota passes at 8 GB. Bluefin's ostree deployment needs more headroom. +12 GB has been tested but not with the `containers-storage:` transport + +bootcDirect approach. + +### 5. Fisherman fork + +Bluefin needs a forked fisherman +(`projectbluefin/fisherman#fix/overlay-driver-for-ostree-bootc-install`) +because the upstream tuna-os/fisherman doesn't support the `--source-imgref` +flag for the direct (bootcDirect) mode. The fork adds: + +1. `BuildBootcArgs` emits `--source-imgref containers-storage:` for + direct-mode installs (when SourceImgref is empty, TargetImgref is set). +2. `bareImageRef()` is called on target-imgref to strip transport prefixes. +3. The `selectStorageDriver` composefs guard is removed (unused in direct + mode but needed for the container-mode fallback). + +If the `containers-storage:` transport + bootcDirect approach works, these +changes should be upstreamed to tuna-os/fisherman and the forked build step +removed from CI. + +## Current status + +**✅ NEW: offline-capable path working** — run `27702412035`: bluefin + bluefin-stable PASSED +with `--source-imgref containers-storage:ghcr.io/ublue-os/bluefin:stable` (containers-storage +transport) + bootcDirect at 8 GB VM RAM. No squash, no second disk, no podman container, +no network pull. The image is read from the embedded squashfs at `/usr/lib/containers/storage`. + +**Bluefin-lts:** pre-existing dracut build failure (kernel `6.12.0-228.el10` in Debian +initramfs-builder) — unrelated to LUKS test changes. + +**Key insight that made it work:** removing the `podman commit -s` squashing step. +The squashing was added for VFS memory pressure (commit `3b8322b`), but the +containers-storage import now uses overlay driver. Without squashing, ostree +annotations (`ostree.final-diffid`) survive into the embedded store, and bootc +resolves them correctly. + +**Fisherman fork needed:** upstream tuna-os/fisherman lacks the `--source-imgref` +emission for direct mode. The essential patch is ~10 lines in `BuildBootcArgs`. +See PR to upstream. + +**Previous failure chain (resolved):** + +| CI Run | ISO Commit | Fisherman Commit | Failure | +|--------|-----------|-----------------|---------| +| 27684346872 | e4a6039 | d5c3b3e | `Unknown transport 'ostree-unverified-registry'` | +| 27682666045 | 94e2473 | d5c3b3e | `Either --source-imgref must be defined...` | +| 27681019431 | ba3ec5f | d5c3b3e | Same as above | +| 27679316314 | 58c8ed2 | d5c3b3e | Same as above | +| 27677273567 | 50df7d8 | 266b4fb | OOM (12 GB, podman run) | +| 27674960446 | 136ae7d | 266b4fb | OOM (10 GB, podman run) | +| 27673343778 | a9e081b | 266b4fb | OOM (8 GB, podman run) | +| 27670315536 | 8dec7d5 | 266b4fb | OOM (8 GB, podman pull) | + +## Files changed + +### `projectbluefin/iso` (PR #61, branch `feat/bluefin-bootc-iso`) + +| File | Change | +|------|--------| +| `justfile` | Added `fisher_repo` var, rebuilt `luks-install-qemu` for bootcDirect, removed second disk and cs-setup.sh | +| `.github/workflows/test-luks-install-bootc.yml` | Added Go setup, fisherman clone, FISHER_REPO env var | +| `bluefin/` | payload_ref, images.json, recipe.json (new variant files) | +| `bluefin-lts/` | Same (bluefin-lts variant) | +| `Containerfile` | 3-stage ISO build (Bluefin + Debian initramfs + final) | +| `src/` | configure-live.sh, build-iso.sh, dracut module, branding assets | + +### `projectbluefin/fisherman` (branch `fix/overlay-driver-for-ostree-bootc-install`) + +| File | Change | +|------|--------| +| `internal/install/bootc.go` | `BuildBootcArgs`: emits `--source-imgref containers-storage:` for direct mode; `bareImageRef` on target-imgref | +| `internal/install/storage_driver.go` | Removed composefs-only guard from `selectStorageDriver`; removed btrfs from unsafeFS list | +| `internal/install/bootc_test.go` | New tests for direct-mode args, OCI export guards | +| `internal/install/storage_driver_test.go` | Updated for new `selectStorageDriver` sig | +| `internal/install/storage_driver_loopback_test.go` | Same | + +## Open questions + +1. ~~Does `--source-imgref containers-storage:ghcr.io/ublue-os/bluefin:stable` work~~ + **RESOLVED** — works with bootcDirect at 8 GB when squashing is removed. + +2. ~~Is 8 GB enough for ostree bootcDirect?~~ **RESOLVED** — 8 GB is sufficient. + bootcDirect avoids podman's container runtime overhead entirely. + +3. **Cleanup dead patches** — commits `1b70f55` through `ea7987b` in the fisherman + fork (overlay/OCI container-mode patches) should be removed from the branch. + Only the direct-mode `--source-imgref` change + `bareImageRef` fix + tests are + needed. + +4. **Upstream fisherman fix** — the ~10-line `--source-imgref` change in + `BuildBootcArgs` should be submitted as a PR to tuna-os/fisherman. + Once merged, the forked binary build step can be removed from CI. + +5. **bluefin-lts dracut failure** — kernel `6.12.0-228.el10` in the Debian + initramfs-builder causes dracut to fail. Unrelated to LUKS test changes. + Needs a separate Containerfile fix (different dracut version or kernel path). diff --git a/bootc-iso/README.md b/bootc-iso/README.md new file mode 100644 index 0000000..2257ac2 --- /dev/null +++ b/bootc-iso/README.md @@ -0,0 +1,59 @@ +# bootc-iso: experimental bootc-installer ISO builder + +This directory resurrects the bootc-installer ISO builder originally merged in +[PR #61](https://github.com/projectbluefin/iso/pull/61) (by @hanthor) and +reverted in [PR #66](https://github.com/projectbluefin/iso/pull/66). It is +fully self-contained: nothing here touches the Anaconda/titanoboa build system +at the repository root, and its CI workflow +(`.github/workflows/test-luks-install-bootc.yml`) runs on `workflow_dispatch` +only. + +## What this is + +A live-ISO builder where the installer is **fisherman** (the bootc-installer +Flatpak) performing `bootcDirect` installs from an embedded +containers-storage store: + +- `justfile` — `iso-sd-boot ` builds the ISO; `luks-test-qemu ` + runs the LUKS-encrypted install end-to-end in QEMU (also the CI entry point). +- `Containerfile` — 3-stage build of the live environment (base image + + live-session configuration + fisherman installer). +- `Containerfile.builder` — Debian-based ISO assembly container + (systemd-boot + dmsquash-live, via `src/build-iso.sh`). +- `bluefin/`, `bluefin-lts/` — per-variant config (`payload_ref` with the base + image reference). +- `src/` — live-session configuration (`configure-live.sh`), ISO assembly + (`build-iso.sh`), dracut module (`95bluefin-isofile`), branding, LUKS test + helpers. +- `scripts/configure_podman_storage.sh` — CI helper choosing a podman storage + driver for the runner (was `.github/scripts/` in #61). +- `HANDOFF.md` — detailed engineering handoff notes from the original effort. + +## Why it was reverted (known problems, not yet solved here) + +1. **ISO size blowup — no dedupe between live rootfs and embedded container + image.** The ISO carries the OS twice: once as the live squashfs rootfs and + once as the payload image inside containers-storage. With the `vfs` storage + driver the store is flat copies (no layer sharing at all). Switching the + embedded store to the `overlay` driver conflicted with `ostree`-based + `bootc install`; that was patched in the fisherman fork branch + `projectbluefin/fisherman` @ `fix/overlay-driver-for-ostree-bootc-install`, + which the CI workflow builds from source. +2. **bluefin-lts never built** due to a dracut failure — see + [iso issue #63](https://github.com/projectbluefin/iso/issues/63). + +## Intended fix direction + +Move to a **single-copy design**: mount the live rootfs directly out of the +embedded container store (composefs/erofs), so the installer payload and the +live environment share one copy of the OS content instead of duplicating it in +a separate squashfs. That eliminates the dedupe problem structurally rather +than fighting the storage driver. + +## Usage + +```bash +cd bootc-iso +just iso-sd-boot bluefin # build output/bluefin-live.iso +just luks-test-qemu bluefin # LUKS install E2E in QEMU +``` diff --git a/bootc-iso/bluefin-lts/payload_ref b/bootc-iso/bluefin-lts/payload_ref new file mode 100644 index 0000000..2cda6ef --- /dev/null +++ b/bootc-iso/bluefin-lts/payload_ref @@ -0,0 +1 @@ +ghcr.io/ublue-os/bluefin:lts diff --git a/bootc-iso/bluefin/payload_ref b/bootc-iso/bluefin/payload_ref new file mode 100644 index 0000000..f59758c --- /dev/null +++ b/bootc-iso/bluefin/payload_ref @@ -0,0 +1 @@ +ghcr.io/ublue-os/bluefin:stable diff --git a/bootc-iso/justfile b/bootc-iso/justfile new file mode 100644 index 0000000..7fc8e46 --- /dev/null +++ b/bootc-iso/justfile @@ -0,0 +1,777 @@ +image-builder := "image-builder" +image-builder-dev := "image-builder-dev" + +# Output directory for built ISOs and intermediate artifacts. +# Override with: just output_dir=/your/path iso-sd-boot bluefin +output_dir := "output" + +# Working directory for ISO builds where container storage staging +# and the squashfs-root are stored. +# Override with: just workdir=/your/path iso-sd-boot bluefin +workdir := output_dir + +# Set to 1 to enable SSH in the live session for debugging. +# Never use debug=1 for production/release ISOs. +debug := "0" + +# Set to "dev" to pull the bootc-installer dev build (continuous-dev release). +installer_channel := "stable" + +# LUKS passphrase used by luks-install for testing. +luks-passphrase := "testpassphrase" + +# Squashfs compression preset: +# fast (default) — zstd level 3, 128K blocks — quick local builds/CI +# release — zstd level 15, 1M blocks — ~20% smaller, ~5× slower +compression := "fast" + +# Path to the projectbluefin/fisherman repo for building the patched fisherman binary. +fisher_repo := "../fisherman/fisherman" + +# Create an XFS loopback mount at /mnt for faster VFS import. +mount-xfs: + #!/usr/bin/bash + set -euo pipefail + if findmnt -n -o FSTYPE /mnt 2>/dev/null | grep -q '^xfs$'; then + echo "/mnt is already XFS — skipping" + exit 0 + fi + echo "Creating 45G XFS loopback at /mnt..." + IMG="/var/tmp/bluefin-xfs-loopback.img" + truncate -s 0 "${IMG}" + chattr +C "${IMG}" 2>/dev/null || true + fallocate -l 45G "${IMG}" + mkfs.xfs -f "${IMG}" + mount -o loop "${IMG}" /mnt + echo "XFS mounted at /mnt (45G)" + echo "" + echo "Now run your build with workdir on /mnt:" + echo " just workdir=/mnt iso-sd-boot bluefin" + df -h /mnt + +# Build the ISO in the background, detached from the terminal session. +build-bg target: + #!/usr/bin/bash + set -euo pipefail + mkdir -p {{ output_dir }} + LOG=$(realpath {{ output_dir }})/build.log + echo "Starting background build → ${LOG}" + setsid \ + debug={{ debug }} \ + installer_channel={{ installer_channel }} \ + output_dir={{ output_dir }} \ + compression={{ compression }} \ + just iso-sd-boot {{ target }} \ + > "${LOG}" 2>&1 & + disown $! + echo "Build PID $! — tailing log (Ctrl-C is safe, build continues)" + tail -f "${LOG}" + +# Helper: returns "--bootc-installer-payload-ref " or "" if no payload_ref file +_payload_ref_flag target: + @if [ -f "{{ target }}/payload_ref" ]; then echo "--bootc-installer-payload-ref $(cat '{{ target }}/payload_ref' | tr -d '[:space:]')"; fi + +# Map target to filesystem: bluefin=btrfs, bluefin-lts=xfs. Default=btrfs. +_filesystem_for target: + @if [ "{{ target }}" = "bluefin-lts" ]; then echo "xfs"; else echo "btrfs"; fi + +container target: + @test -f "{{ target }}/payload_ref" || { echo "ERROR: {{ target }}/payload_ref not found — create it with the base image reference, e.g.: echo 'ghcr.io/ublue-os/bluefin:stable' > {{ target }}/payload_ref"; exit 1; } + podman build --cap-add sys_admin --security-opt label=disable \ + --layers \ + --build-arg DEBUG={{ debug }} \ + --build-arg INSTALLER_CHANNEL={{ installer_channel }} \ + --build-arg BASE_IMAGE=$(cat {{ target }}/payload_ref | tr -d '[:space:]') \ + --build-arg FILESYSTEM=$(just _filesystem_for {{ target }}) \ + -t {{ target }}-installer -f ./Containerfile . + +# Build the Debian-based ISO assembly container for the given target. +iso-builder target: + podman build --security-opt label=disable -t {{ target }}-iso-builder \ + -f ./Containerfile.builder . + +# Build a UEFI live ISO for the given target using systemd-boot and dmsquash-live. +# +# Uses a two-container approach: +# 1. localhost/-installer — the live environment (3-stage Containerfile) +# 2. localhost/-iso-builder — Debian ISO assembly tools (Containerfile.builder) +# +# Output: output/-live.iso +iso-sd-boot target: + #!/usr/bin/bash + set -euo pipefail + PAYLOAD_IMAGE=$(cat "{{ target }}/payload_ref" | tr -d '[:space:]') + + mkdir -p {{ output_dir }} + OUTPUT_DIR=$(realpath "{{ output_dir }}") + WORKDIR=$(realpath "{{ workdir }}") + + echo "=== Disk space before container build ===" + df -h "${OUTPUT_DIR}" + + if ! findmnt -n -o FSTYPE -T "${WORKDIR}" 2>/dev/null | grep -qE '^(xfs|btrfs)$'; then + echo "Hint: $WORKDIR is not an XFS/BTRFS mount. For faster VFS import, run:" >&2 + echo " sudo just mount-xfs" >&2 + echo " sudo just workdir=/mnt iso-sd-boot {{ target }}" >&2 + fi + + AVAILABLE_KB=$(df --output=avail -B1024 "${OUTPUT_DIR}" | tail -1 | tr -d ' ') + REQUIRED_KB=$((20 * 1024 * 1024)) + if [ "$AVAILABLE_KB" -lt "$REQUIRED_KB" ]; then + echo "WARNING: Only $(( AVAILABLE_KB / 1024 / 1024 ))GB free on $(df --output=target "${OUTPUT_DIR}" | tail -1) — ISO output needs ~5GB, full build needs more" >&2 + fi + podman images --format "table {{{{.Repository}}}}\t{{{{.Tag}}}}\t{{{{.Size}}}}" 2>/dev/null || true + + just debug={{ debug }} installer_channel={{ installer_channel }} container {{ target }} + + echo "=== Disk space after container build ===" + df -h "${OUTPUT_DIR}" + podman images --format "table {{{{.Repository}}}}\t{{{{.Tag}}}}\t{{{{.Size}}}}" 2>/dev/null || true + + podman rmi debian:sid 2>/dev/null || true + podman image prune -f 2>/dev/null || true + echo "=== Disk space after intermediate cleanup ===" + df -h "${OUTPUT_DIR}" + + if [[ $(id -u) -eq 0 ]]; then + _ns() { bash -c "$1"; } + else + _ns() { podman unshare bash -c "$1"; } + fi + + SQUASHFS="${OUTPUT_DIR}/{{ target }}-rootfs.sfs" + BOOT_TAR="${OUTPUT_DIR}/{{ target }}-boot-files.tar" + CS_STAGING="${WORKDIR}/{{ target }}-cs-staging" + SQUASHFS_ROOT="${WORKDIR}/{{ target }}-sfs-root" + trap "rm -f '${SQUASHFS}' '${BOOT_TAR}' '${OUTPUT_DIR}/{{ target }}-payload.oci.tar' 2>/dev/null || true" EXIT + echo "=== Disk space before squashfs assembly ===" + df -h "${OUTPUT_DIR}" + if [[ "$WORKDIR" != "$OUTPUT_DIR" ]]; then + df -h "${WORKDIR}" + fi + echo "Building squashfs and boot tar from localhost/{{ target }}-installer..." + _ns " + set -euo pipefail + + SQUASHFS_ROOT='${SQUASHFS_ROOT}' + CS_STAGING='${CS_STAGING}' + OVERLAY_UPPER=\$(mktemp -d \"\${SQUASHFS_ROOT}_upper_XXXXXX\") + OVERLAY_WORK=\$(mktemp -d \"\${SQUASHFS_ROOT}_work_XXXXXX\") + + ns_cleanup() { + umount \"\${SQUASHFS_ROOT}/usr/lib/containers/storage\" 2>/dev/null || true + umount \"\${SQUASHFS_ROOT}\" 2>/dev/null || true + podman image unmount localhost/{{ target }}-installer 2>/dev/null || true + rm -rf \"\${OVERLAY_UPPER}\" \"\${OVERLAY_WORK}\" 2>/dev/null || true + rm -rf \"\${CS_STAGING}\" \"\${SQUASHFS_ROOT}\" 2>/dev/null || true + } + trap ns_cleanup EXIT + + MOUNT=\$(podman image mount localhost/{{ target }}-installer) + PATH=/usr/sbin:/usr/bin:/home/linuxbrew/.linuxbrew/bin:\$PATH + + PAYLOAD_OCI='${OUTPUT_DIR}/{{ target }}-payload.oci.tar' + SQUASHFS_STORAGE=\"\${CS_STAGING}/usr/lib/containers/storage\" + STORAGE_CONF=\"\$(mktemp '${OUTPUT_DIR}'/live-storage-XXXXXX.conf)\" + mkdir -p \"\${SQUASHFS_STORAGE}\" + printf '[storage]\ndriver = \"overlay\"\nrunroot = \"/tmp/cs-runroot\"\ngraphroot = \"/vfs-storage\"\n' \ + > \"\${STORAGE_CONF}\" + + podman save -o \"\${PAYLOAD_OCI}\" --format oci-archive '"${PAYLOAD_IMAGE}"' + + + echo 'Importing Bluefin OCI image into squashfs containers-storage...' + echo '=== Disk space before VFS import ===' + df -h '${OUTPUT_DIR}' + if [[ '$WORKDIR' != '$OUTPUT_DIR' ]]; then + df -h '${WORKDIR}' + fi + podman run --rm \ + --privileged \ + -v \"\${PAYLOAD_OCI}:/payload.oci.tar:ro\" \ + -v \"\${SQUASHFS_STORAGE}:/vfs-storage\" \ + -v \"\${STORAGE_CONF}:/tmp/st.conf:ro\" \ + localhost/{{ target }}-installer \ + sh -c 'mkdir -p /tmp/cs-runroot /var/tmp && CONTAINERS_STORAGE_CONF=/tmp/st.conf skopeo copy oci-archive:/payload.oci.tar:'"${PAYLOAD_IMAGE}"' containers-storage:'"${PAYLOAD_IMAGE}"'' + + rm -f \"\${PAYLOAD_OCI}\" \"\${STORAGE_CONF}\" + + echo '=== Disk space after VFS import ===' + df -h '${OUTPUT_DIR}' + if [[ '$WORKDIR' != '$OUTPUT_DIR' ]]; then + df -h '${WORKDIR}' + fi + du -sh \"\${CS_STAGING}\" 2>/dev/null || true + + echo 'Building unified squashfs source tree using bind mounts...' + mkdir -p \"\${SQUASHFS_ROOT}\" + + FS_TYPE=\$(findmnt -n -o FSTYPE -T \"\${SQUASHFS_ROOT}\" 2>/dev/null || echo \"unknown\") + if [[ \"\${FS_TYPE}\" == \"xfs\" || \"\${FS_TYPE}\" == \"ext4\" ]]; then + echo \"Filesystem is \${FS_TYPE}, trying overlay\" + if ! mount -t overlay overlay \ + -o lowerdir=\"\${MOUNT}\",upperdir=\"\${OVERLAY_UPPER}\",workdir=\"\${OVERLAY_WORK}\" \"\${SQUASHFS_ROOT}\"; then + echo \"Overlay mount failed on \${FS_TYPE}; falling back to cp -a\" + cp -a \"\${MOUNT}/.\" \"\${SQUASHFS_ROOT}/\" + fi + else + echo \"Filesystem is \${FS_TYPE}, doing it the boring way\" + cp -a \"\${MOUNT}/.\" \"\${SQUASHFS_ROOT}/\" + fi + + mkdir -p \"\${SQUASHFS_ROOT}/usr/lib/containers/storage\" + mount --bind \"\${CS_STAGING}/usr/lib/containers/storage\" \"\${SQUASHFS_ROOT}/usr/lib/containers/storage\" + echo '=== Disk space after creation of squashfs root ===' + df -h '${OUTPUT_DIR}' + if [[ '$WORKDIR' != '$OUTPUT_DIR' ]]; then + df -h '${WORKDIR}' + fi + du -sh \"\${SQUASHFS_ROOT}\" 2>/dev/null || true + + SFS_LEVEL=3; SFS_BLOCK=131072 + [[ '{{ compression }}' == 'release' ]] && { SFS_LEVEL=15; SFS_BLOCK=1048576; } + mksquashfs \"\${SQUASHFS_ROOT}\" '${SQUASHFS}' \ + -noappend -comp zstd -Xcompression-level \${SFS_LEVEL} -b \${SFS_BLOCK} \ + -processors 4 \ + -e proc -e sys -e dev -e run -e tmp + + tar -C \"\$MOUNT\" \ + -cf '${BOOT_TAR}' \ + ./usr/lib/modules \ + ./usr/lib/systemd/boot/efi + " + + echo "=== Disk space after squashfs, before ISO assembly ===" + df -h "${OUTPUT_DIR}" + du -sh "${SQUASHFS}" "${BOOT_TAR}" 2>/dev/null || true + + TMPDIR="${OUTPUT_DIR}" \ + PATH="/usr/sbin:/usr/bin:/home/linuxbrew/.linuxbrew/bin:${PATH}" \ + bash "src/build-iso.sh" "${BOOT_TAR}" "${SQUASHFS}" "${OUTPUT_DIR}/{{ target }}-live.iso" + + echo "ISO ready: ${OUTPUT_DIR}/{{ target }}-live.iso" + +# ── QEMU and libvirt boot / LUKS testing recipes ───────────────────────────── + +# Boot a built ISO in QEMU via UEFI (OVMF) with serial console output on stdout. +boot-iso-serial target: + #!/usr/bin/bash + set -euo pipefail + QEMU=$(command -v /usr/libexec/qemu-kvm /usr/bin/qemu-kvm \ + /usr/bin/qemu-system-x86_64 \ + /home/linuxbrew/.linuxbrew/bin/qemu-system-x86_64 2>/dev/null | head -1) + [[ -z "$QEMU" ]] && { echo "qemu-kvm / qemu-system-x86_64 not found" >&2; exit 1; } + ISO=$(ls \ + {{ output_dir }}/{{ target }}-live.iso \ + output/bootiso/install.iso \ + output/bootc-{{ target }}*.iso \ + 2>/dev/null | head -1 || true) + if [[ -z "$ISO" ]]; then + echo "No ISO found for '{{ target }}' — run: just iso-sd-boot {{ target }}" >&2 + exit 1 + fi + + OVMF_CODE="" + for f in \ + /usr/share/OVMF/OVMF_CODE.fd \ + /usr/share/edk2/ovmf/OVMF_CODE.fd \ + /usr/share/edk2-ovmf/x64/OVMF_CODE.fd \ + /usr/share/ovmf/OVMF.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-x86_64-code.fd \ + /home/linuxbrew/.linuxbrew/Cellar/qemu/11.0.0/share/qemu/edk2-x86_64-code.fd; do + [[ -f "$f" ]] && { OVMF_CODE="$f"; break; } + done + OVMF_VARS_SRC="" + for f in \ + /usr/share/OVMF/OVMF_VARS.fd \ + /usr/share/edk2/ovmf/OVMF_VARS.fd \ + /usr/share/edk2-ovmf/x64/OVMF_VARS.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-i386-vars.fd; do + [[ -f "$f" ]] && { OVMF_VARS_SRC="$f"; break; } + done + if [[ -z "$OVMF_CODE" ]]; then + echo "OVMF firmware not found — install edk2-ovmf or ovmf" >&2 + exit 1 + fi + + OVMF_VARS=$(mktemp /tmp/OVMF_VARS.XXXXXX.fd) + [[ -n "$OVMF_VARS_SRC" ]] && cp "${OVMF_VARS_SRC}" "${OVMF_VARS}" + trap "rm -f ${OVMF_VARS}" EXIT + + echo "Booting ${ISO} via UEFI — serial console below (Ctrl-A X to quit)" + echo "SSH available on localhost:2222 (user: liveuser, password: live) if built with debug=1" + "$QEMU" \ + -machine q35 \ + -m 4096 \ + -accel kvm \ + -cpu host \ + -smp 4 \ + -drive if=pflash,format=raw,readonly=on,file="${OVMF_CODE}" \ + -drive if=pflash,format=raw,file="${OVMF_VARS}" \ + -drive if=none,id=live-disk,file="${ISO}",media=cdrom,format=raw,readonly=on \ + -device virtio-scsi-pci,id=scsi \ + -device scsi-cd,drive=live-disk \ + -net nic,model=virtio -net user,hostfwd=tcp::2222-:22 \ + -serial mon:stdio \ + -display none \ + -no-reboot + +# Boot a built ISO in libvirt with UEFI, a target install disk, and SSH via +# the default libvirt network. +boot-libvirt-debug target: + #!/usr/bin/bash + set -euo pipefail + + VM_NAME="bluefin-debug" + VM_RAM=8192 + VM_CPUS=4 + DISK_SIZE=64 + + ISO=$(ls \ + {{ output_dir }}/{{ target }}-live.iso \ + output/bootiso/install.iso \ + output/bootc-{{ target }}*.iso \ + 2>/dev/null | head -1 || true) + if [[ -z "$ISO" ]]; then + echo "No ISO found for '{{ target }}' — run: just debug=1 iso-sd-boot {{ target }}" >&2 + exit 1 + fi + + OVMF_CODE="" + for f in \ + /usr/share/OVMF/OVMF_CODE.fd \ + /usr/share/edk2/ovmf/OVMF_CODE.fd \ + /usr/share/edk2-ovmf/x64/OVMF_CODE.fd \ + /usr/share/ovmf/OVMF.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-x86_64-code.fd \ + /home/linuxbrew/.linuxbrew/Cellar/qemu/11.0.0/share/qemu/edk2-x86_64-code.fd; do + [[ -f "$f" ]] && { OVMF_CODE="$f"; break; } + done + OVMF_VARS="" + for f in \ + /usr/share/OVMF/OVMF_VARS.fd \ + /usr/share/edk2/ovmf/OVMF_VARS.fd \ + /usr/share/edk2-ovmf/x64/OVMF_VARS.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-i386-vars.fd; do + [[ -f "$f" ]] && { OVMF_VARS="$f"; break; } + done + if [[ -z "$OVMF_CODE" ]]; then + echo "OVMF firmware not found — install edk2-ovmf or ovmf" >&2 + exit 1 + fi + + sudo cp "$ISO" /var/lib/libvirt/images/${VM_NAME}.iso + + if sudo virsh dominfo "$VM_NAME" &>/dev/null; then + echo "VM '${VM_NAME}' already exists — swapping ISO and rebooting..." + sudo virsh destroy "$VM_NAME" 2>/dev/null || true + CDROM_DEV=$(sudo virsh domblklist "$VM_NAME" \ + | awk 'NR>2 && $2 == "-" {print $1; exit}') + if [[ -z "$CDROM_DEV" ]]; then + CDROM_DEV=$(sudo virsh domblklist "$VM_NAME" \ + | awk 'NR>2 && ($2 ~ /\.iso$/) {print $1; exit}') + fi + sudo virsh change-media "$VM_NAME" "$CDROM_DEV" \ + /var/lib/libvirt/images/${VM_NAME}.iso --force + sudo virsh start "$VM_NAME" + else + echo "Creating libvirt VM: ${VM_NAME} (${VM_RAM}M RAM, ${VM_CPUS} vCPUs, ${DISK_SIZE}G disk)" + sudo virt-install \ + --name "$VM_NAME" \ + --memory "$VM_RAM" --vcpus "$VM_CPUS" \ + --boot loader="${OVMF_CODE}",loader.readonly=yes,loader.type=pflash,nvram.template="${OVMF_VARS}" \ + --cdrom /var/lib/libvirt/images/${VM_NAME}.iso \ + --disk size=${DISK_SIZE},format=qcow2 \ + --network network=default \ + --graphics vnc,listen=127.0.0.1 \ + --os-variant generic \ + --tpm none \ + --noautoconsole + fi + + MAC=$(sudo virsh domiflist "$VM_NAME" | awk '/network/{print $5}') + echo "VM started. MAC: ${MAC}" + echo "Waiting for DHCP lease (this takes 30-90s while the ISO boots)..." + + GUEST_IP="" + for i in $(seq 1 60); do + GUEST_IP=$(sudo virsh net-dhcp-leases default 2>/dev/null \ + | awk -v mac="$MAC" '$3 == mac {split($5, a, "/"); print a[1]}' \ + | head -1) + if [[ -n "$GUEST_IP" ]]; then + break + fi + sleep 3 + done + + if [[ -z "$GUEST_IP" ]]; then + echo "WARNING: No DHCP lease found after 3 minutes." >&2 + echo "Try: sudo virsh net-dhcp-leases default" >&2 + echo "Or: sudo virsh console ${VM_NAME}" >&2 + exit 1 + fi + + echo "" + echo "========================================" + echo " SSH ready:" + echo " ssh liveuser@${GUEST_IP}" + echo " password: live" + echo "========================================" + echo "" + echo "VNC: $(sudo virsh domdisplay ${VM_NAME} 2>/dev/null || echo 'unavailable')" + echo "Serial: sudo virsh console ${VM_NAME}" + echo "Cleanup: sudo virsh destroy ${VM_NAME} && sudo virsh undefine ${VM_NAME} --nvram" + +# Run LUKS encrypted install via fisherman into the running bluefin-debug libvirt VM. +luks-install target: + #!/usr/bin/bash + set -euo pipefail + + VM_NAME="bluefin-debug" + PASSPHRASE="{{ luks-passphrase }}" + DISK="/dev/sda" + PAYLOAD_IMAGE=$(cat "{{ target }}/payload_ref" | tr -d '[:space:]') + SSH_OPTS="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR -o ConnectTimeout=5 -o IdentitiesOnly=yes -o PreferredAuthentications=password" + SSH="sshpass -p live ssh $SSH_OPTS" + SCP="sshpass -p live scp $SSH_OPTS" + + MAC=$(sudo virsh domiflist "$VM_NAME" 2>/dev/null | awk '/network/{print $5; exit}') + if [[ -z "$MAC" ]]; then + echo "ERROR: VM '${VM_NAME}' is not running." + echo "Start it first: just debug=1 boot-libvirt-debug {{ target }}" + exit 1 + fi + + GUEST_IP="" + echo "Looking up DHCP lease for ${VM_NAME} (${MAC})..." + for i in $(seq 1 20); do + GUEST_IP=$(sudo virsh net-dhcp-leases default 2>/dev/null \ + | awk -v mac="$MAC" '$3 == mac {split($5, a, "/"); print a[1]}' \ + | head -1) + [[ -n "$GUEST_IP" ]] && break + sleep 3 + done + if [[ -z "$GUEST_IP" ]]; then + echo "ERROR: no DHCP lease found — is the VM fully booted?" + echo "Check: sudo virsh net-dhcp-leases default" + exit 1 + fi + echo "Guest IP: ${GUEST_IP}" + + echo "Waiting for SSH..." + for i in $(seq 1 30); do + $SSH liveuser@"$GUEST_IP" true 2>/dev/null && break + sleep 3 + done + $SSH liveuser@"$GUEST_IP" true || { echo "ERROR: SSH timed out"; exit 1; } + + FILESYSTEM=$(just _filesystem_for "{{ target }}") + RECIPE_TMP=$(mktemp /tmp/luks-recipe-XXXXXX.json) + trap "rm -f '${RECIPE_TMP}'" EXIT + printf '{\n "disk": "%s",\n "filesystem": "%s",\n "image": "%s",\n "composeFsBackend": false,\n "bootloader": "grub2",\n "hostname": "bluefin-luks-test",\n "encryption": {"type": "luks-passphrase", "passphrase": "%s"},\n "flatpaks": []\n}\n' \ + "${DISK}" "${FILESYSTEM}" "${PAYLOAD_IMAGE}" "${PASSPHRASE}" > "${RECIPE_TMP}" + $SCP "${RECIPE_TMP}" liveuser@"$GUEST_IP":/tmp/luks-recipe.json + echo "Uploaded recipe to /tmp/luks-recipe.json" + + echo "Running fisherman install (pulls from registry, takes several minutes)..." + $SSH liveuser@"$GUEST_IP" 'sudo /usr/local/bin/fisherman /tmp/luks-recipe.json' + echo "Install finished." + + CDROM_DEV=$(sudo virsh domblklist "$VM_NAME" \ + | awk 'NR>2 && ($2 ~ /\.iso$/ || $2 == "-") {print $1; exit}') + if [[ -n "$CDROM_DEV" ]]; then + sudo virsh change-media "$VM_NAME" "$CDROM_DEV" --eject --force 2>/dev/null || true + echo "ISO ejected from ${CDROM_DEV}." + else + echo "Warning: could not identify CD-ROM device; eject skipped." + fi + + echo "Rebooting VM into installed system..." + sudo virsh reboot "$VM_NAME" || $SSH liveuser@"$GUEST_IP" 'sudo reboot' || true + + echo "" + echo "========================================" + echo " VM is rebooting into the installed system." + echo " Unlock LUKS: just luks-unlock {{ target }}" + echo " Watch boot: just luks-boot {{ target }}" + echo "========================================" + +# Automate LUKS passphrase entry on the bluefin-debug VM serial console. +luks-unlock target: + #!/usr/bin/bash + VM_NAME="bluefin-debug" + PASSPHRASE="{{ luks-passphrase }}" + if ! sudo virsh domstate "$VM_NAME" 2>/dev/null | grep -q running; then + echo "ERROR: VM '${VM_NAME}' is not running." + echo "Run: just luks-install {{ target }}" + exit 1 + fi + MAC=$(sudo virsh domiflist "$VM_NAME" 2>/dev/null | awk '/network/{print $5; exit}') + if [[ -z "$MAC" ]]; then + echo "ERROR: VM '${VM_NAME}' is not running." + exit 1 + fi + echo "Waiting for Plymouth passphrase prompt (VM MAC: ${MAC})..." + echo "Passphrase: ${PASSPHRASE}" + sudo python3 "src/luks-unlock.py" libvirt "$VM_NAME" "$PASSPHRASE" "$MAC" + +# Connect to the serial console of the bluefin-debug VM. +luks-boot target: + #!/usr/bin/bash + VM_NAME="bluefin-debug" + if ! sudo virsh domstate "$VM_NAME" 2>/dev/null | grep -q running; then + echo "ERROR: VM '${VM_NAME}' is not running." + echo "Run: just luks-install {{ target }}" + exit 1 + fi + echo "Connecting to serial console (detach: Ctrl-])" + echo "At the LUKS passphrase prompt type: {{ luks-passphrase }}" + echo "" + sudo virsh console "$VM_NAME" + +# ── QEMU-native LUKS test (used by CI; mirrors the libvirt recipes) ─────────── + +luks-qemu-disk := "/var/tmp/bluefin-luks-install.qcow2" +luks-qemu-monitor-live := "/tmp/bluefin-qemu-live.sock" +luks-qemu-monitor-installed := "/tmp/bluefin-qemu-installed.sock" +luks-qemu-serial-live := "/tmp/bluefin-qemu-live-serial.log" +luks-qemu-serial-installed := "/tmp/bluefin-qemu-installed-serial.log" +luks-qemu-ssh-port := "2222" +# SSH port forwarded into the installed (post-LUKS-unlock) VM for boot detection. +luks-qemu-ssh-port-installed := "2223" +luks-qemu-ram := "8192" + +# Full end-to-end test: build the ISO then run the LUKS install + boot test. +e2e target: + #!/usr/bin/bash + set -euo pipefail + echo "=== Step 1/2: Building ISO (debug={{ debug }}, installer_channel={{ installer_channel }}) ===" + just debug={{ debug }} installer_channel={{ installer_channel }} output_dir={{ output_dir }} iso-sd-boot {{ target }} + echo "=== Step 2/2: LUKS end-to-end test ===" + sudo rm -f "{{ luks-qemu-disk }}" "{{ luks-qemu-monitor-live }}" "{{ luks-qemu-monitor-installed }}" \ + "{{ luks-qemu-serial-live }}" "{{ luks-qemu-serial-installed }}" + just luks-test-qemu {{ target }} + +# Run the full LUKS end-to-end test in QEMU (CI entry point). +luks-test-qemu target: + #!/usr/bin/bash + set -euo pipefail + just luks-qemu-disk={{ luks-qemu-disk }} luks-boot-qemu-live {{ target }} + just luks-qemu-ssh-port={{ luks-qemu-ssh-port }} luks-install-qemu {{ target }} + just luks-qemu-disk={{ luks-qemu-disk }} \ + luks-qemu-ssh-port-installed={{ luks-qemu-ssh-port-installed }} \ + luks-boot-qemu-installed {{ target }} + just luks-qemu-monitor-installed={{ luks-qemu-monitor-installed }} \ + luks-qemu-serial-installed={{ luks-qemu-serial-installed }} \ + luks-qemu-ssh-port-installed={{ luks-qemu-ssh-port-installed }} \ + luks-unlock-qemu {{ target }} + +# Boot the live ISO in QEMU (daemonized) with a blank install disk attached. +luks-boot-qemu-live target: + #!/usr/bin/bash + set -euo pipefail + QEMU=$(command -v /usr/libexec/qemu-kvm /usr/bin/qemu-kvm \ + /usr/bin/qemu-system-x86_64 \ + /home/linuxbrew/.linuxbrew/bin/qemu-system-x86_64 2>/dev/null | head -1) + [[ -z "$QEMU" ]] && { echo "qemu-kvm / qemu-system-x86_64 not found" >&2; exit 1; } + ISO=$(ls \ + {{ output_dir }}/{{ target }}-live.iso \ + output/bootiso/install.iso \ + output/bootc-{{ target }}*.iso \ + 2>/dev/null | head -1 || true) + if [[ -z "$ISO" ]]; then + echo "No ISO found — run: just debug=1 iso-sd-boot {{ target }}" >&2 + exit 1 + fi + + OVMF_CODE=""; OVMF_VARS="" + for f in /usr/share/OVMF/OVMF_CODE_4M.fd /usr/share/OVMF/OVMF_CODE.fd \ + /usr/share/edk2/ovmf/OVMF_CODE.fd /usr/share/ovmf/OVMF.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-x86_64-code.fd \ + /home/linuxbrew/.linuxbrew/Cellar/qemu/11.0.0/share/qemu/edk2-x86_64-code.fd; do + [[ -f "$f" ]] && { OVMF_CODE="$f"; break; } + done + for f in /usr/share/OVMF/OVMF_VARS_4M.fd /usr/share/OVMF/OVMF_VARS.fd \ + /usr/share/edk2/ovmf/OVMF_VARS.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-i386-vars.fd; do + if [[ -f "$f" ]]; then cp "$f" /var/tmp/bluefin-qemu-live-vars.fd; OVMF_VARS=/var/tmp/bluefin-qemu-live-vars.fd; break; fi + done + [[ -z "$OVMF_CODE" ]] && { echo "OVMF firmware not found" >&2; exit 1; } + + [[ -f "{{ luks-qemu-disk }}" ]] || qemu-img create -f qcow2 "{{ luks-qemu-disk }}" 64G + sudo rm -f "{{ luks-qemu-monitor-live }}" "{{ luks-qemu-serial-live }}" + + echo "Booting live ISO: $ISO" + QEMU_ACCEL="-accel kvm" + QEMU_PREFIX="" + if ! test -r /dev/kvm 2>/dev/null; then + if sudo test -r /dev/kvm 2>/dev/null; then + echo "Using sudo for KVM access" + QEMU_PREFIX="sudo" + else + echo "KVM not available, falling back to TCG emulation (slower)" + QEMU_ACCEL="-accel tcg,thread=multi" + QEMU_PREFIX="" + fi + fi + $QEMU_PREFIX "$QEMU" \ + -machine q35 -cpu host -m {{ luks-qemu-ram }} -smp 4 $QEMU_ACCEL \ + -drive "if=pflash,format=raw,readonly=on,file=${OVMF_CODE}" \ + -drive "if=pflash,format=raw,file=${OVMF_VARS}" \ + -drive "if=none,id=iso,file=${ISO},media=cdrom,readonly=on,format=raw" \ + -device virtio-scsi-pci,id=scsi \ + -device scsi-cd,drive=iso \ + -drive "if=none,id=disk,file={{ luks-qemu-disk }},format=qcow2" \ + -device virtio-blk-pci,drive=disk \ + -netdev "user,id=net0,hostfwd=tcp::{{ luks-qemu-ssh-port }}-:22" \ + -device virtio-net-pci,netdev=net0 \ + -monitor "unix:{{ luks-qemu-monitor-live }},server,nowait" \ + -serial "file:{{ luks-qemu-serial-live }}" \ + -display none \ + -daemonize + echo "Live QEMU started (monitor: {{ luks-qemu-monitor-live }})" + + SSH_OPTS="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR -o ConnectTimeout=5 -o PreferredAuthentications=password" + echo "Waiting for live environment on port {{ luks-qemu-ssh-port }}..." + for i in $(seq 1 60); do + if sudo grep -q "BLUEFIN_LIVE_READY" "{{ luks-qemu-serial-live }}" 2>/dev/null; then + echo "Live environment ready (serial marker seen)" + break + fi + if sshpass -p live ssh $SSH_OPTS liveuser@127.0.0.1 -p {{ luks-qemu-ssh-port }} true 2>/dev/null; then + echo "Live environment ready (SSH connected)" + break + fi + [[ "$i" -eq 60 ]] && { echo "ERROR: live env not ready after 5m"; sudo tail -30 "{{ luks-qemu-serial-live }}" || true; exit 1; } + sleep 5 + done + + echo "Live environment ready. Waiting 25s for GUI to fully render..." + sleep 25 + sudo socat - "UNIX-CONNECT:{{ luks-qemu-monitor-live }}" \ + <<< "screendump /tmp/luks-screenshot-live.ppm" 2>/dev/null || true + +# Run fisherman LUKS install via SSH into the live QEMU VM. +luks-install-qemu target: + #!/usr/bin/bash + set -euo pipefail + PASSPHRASE="{{ luks-passphrase }}" + DISK="/dev/vda" + PAYLOAD_IMAGE=$(cat "{{ target }}/payload_ref" | tr -d '[:space:]') + SSH_OPTS="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR -o ConnectTimeout=5 -o PreferredAuthentications=password -o ServerAliveInterval=30 -o ServerAliveCountMax=20" + SSH="sshpass -p live ssh $SSH_OPTS liveuser@127.0.0.1 -p {{ luks-qemu-ssh-port }}" + SCP="sshpass -p live scp $SSH_OPTS -P {{ luks-qemu-ssh-port }}" + + FILESYSTEM=$(just _filesystem_for "{{ target }}") + RECIPE_TMP=$(mktemp /tmp/luks-recipe-XXXXXX.json) + trap "rm -f '${RECIPE_TMP}'" EXIT + # Empty image triggers bootcDirect: fisherman runs `bootc install + # to-filesystem` natively on the live ISO (which IS the Bluefin image). + # No podman, no OCI export, no overlay, no RAM issues. + # target_imgref tells bootc what to track for day-2 updates. + printf '{\n "disk": "%s",\n "filesystem": "%s",\n "image": "",\n "targetImgref": "%s",\n "composeFsBackend": false,\n "bootloader": "grub2",\n "hostname": "bluefin-luks-test",\n "encryption": {"type": "luks-passphrase", "passphrase": "%s"},\n "flatpaks": []\n}\n' \ + "${DISK}" "${FILESYSTEM}" "${PAYLOAD_IMAGE}" "${PASSPHRASE}" > "${RECIPE_TMP}" + $SCP "${RECIPE_TMP}" liveuser@127.0.0.1:/tmp/luks-recipe.json + + # Use the fisherman already installed on the live ISO (Flatpak). + # bootcDirect doesn't need any of our patches — it runs bootc natively. + # Build patched fisherman for the direct-mode --source-imgref fix. + FISHER_REPO="${FISHER_REPO:-{{ fisher_repo }}}" + FISHERMAN_BIN=$(mktemp /tmp/fisherman-XXXXXX) + trap "rm -f '${RECIPE_TMP}' '${FISHERMAN_BIN}'" EXIT + (cd "${FISHER_REPO}" && CGO_ENABLED=0 go build -o "${FISHERMAN_BIN}" ./cmd/fisherman/) + $SCP "${FISHERMAN_BIN}" liveuser@127.0.0.1:/tmp/fisherman + $SSH 'chmod +x /tmp/fisherman' + echo "Running fisherman (direct bootc install, takes several minutes)..." + if ! $SSH 'sudo /tmp/fisherman /tmp/luks-recipe.json'; then + echo "=== INSTALL FAILURE DIAGNOSTICS ===" + echo "--- dmesg ---" + $SSH 'sudo dmesg | tail -n 100' || true + echo "--- journalctl ---" + $SSH 'sudo journalctl -n 100 --no-pager' || true + echo "--- systemd-oomd status ---" + $SSH 'sudo systemctl status systemd-oomd --no-pager' || true + echo "--- podman system info ---" + $SSH 'sudo podman info' || true + exit 1 + fi + echo "Install complete. Shutting down live QEMU..." + echo "system_powerdown" | sudo socat - "UNIX-CONNECT:{{ luks-qemu-monitor-live }}" 2>/dev/null || true + sleep 5 + echo "quit" | sudo socat - "UNIX-CONNECT:{{ luks-qemu-monitor-live }}" 2>/dev/null || true + +# Boot the installed disk in QEMU (no ISO). Called after luks-install-qemu. +luks-boot-qemu-installed target: + #!/usr/bin/bash + set -euo pipefail + QEMU=$(command -v /usr/libexec/qemu-kvm /usr/bin/qemu-kvm \ + /usr/bin/qemu-system-x86_64 \ + /home/linuxbrew/.linuxbrew/bin/qemu-system-x86_64 2>/dev/null | head -1) + [[ -z "$QEMU" ]] && { echo "qemu-kvm / qemu-system-x86_64 not found" >&2; exit 1; } + OVMF_CODE=""; OVMF_VARS="" + for f in /usr/share/OVMF/OVMF_CODE_4M.fd /usr/share/OVMF/OVMF_CODE.fd \ + /usr/share/edk2/ovmf/OVMF_CODE.fd /usr/share/ovmf/OVMF.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-x86_64-code.fd \ + /home/linuxbrew/.linuxbrew/Cellar/qemu/11.0.0/share/qemu/edk2-x86_64-code.fd; do + [[ -f "$f" ]] && { OVMF_CODE="$f"; break; } + done + for f in /usr/share/OVMF/OVMF_VARS_4M.fd /usr/share/OVMF/OVMF_VARS.fd \ + /usr/share/edk2/ovmf/OVMF_VARS.fd \ + /home/linuxbrew/.linuxbrew/share/qemu/edk2-i386-vars.fd; do + if [[ -f "$f" ]]; then cp "$f" /var/tmp/bluefin-qemu-installed-vars.fd; OVMF_VARS=/var/tmp/bluefin-qemu-installed-vars.fd; break; fi + done + [[ -z "$OVMF_CODE" ]] && { echo "OVMF firmware not found" >&2; exit 1; } + + sudo rm -f "{{ luks-qemu-monitor-installed }}" "{{ luks-qemu-serial-installed }}" + + echo "Booting installed disk: {{ luks-qemu-disk }}" + QEMU_ACCEL="-accel kvm" + QEMU_PREFIX="" + if ! test -r /dev/kvm 2>/dev/null; then + if sudo test -r /dev/kvm 2>/dev/null; then + echo "Using sudo for KVM access" + QEMU_PREFIX="sudo" + else + echo "KVM not available, falling back to TCG emulation (slower)" + QEMU_ACCEL="-accel tcg,thread=multi" + QEMU_PREFIX="" + fi + fi + $QEMU_PREFIX "$QEMU" \ + -machine q35 -cpu host -m {{ luks-qemu-ram }} -smp 4 $QEMU_ACCEL \ + -drive "if=pflash,format=raw,readonly=on,file=${OVMF_CODE}" \ + -drive "if=pflash,format=raw,file=${OVMF_VARS}" \ + -drive "if=none,id=disk,file={{ luks-qemu-disk }},format=qcow2" \ + -device virtio-blk-pci,drive=disk \ + -netdev "user,id=net0,hostfwd=tcp::{{ luks-qemu-ssh-port-installed }}-:22" \ + -device virtio-net-pci,netdev=net0 \ + -monitor "unix:{{ luks-qemu-monitor-installed }},server,nowait" \ + -serial "file:{{ luks-qemu-serial-installed }}" \ + -display none \ + -daemonize + echo "Installed QEMU started (monitor: {{ luks-qemu-monitor-installed }})" + + for i in $(seq 1 15); do + [[ -S "{{ luks-qemu-monitor-installed }}" ]] && break + sleep 2 + done + +# Send LUKS passphrase to installed QEMU VM via monitor screendump + sendkey. +# luks-qemu-ssh-port-installed: forwarded SSH port for boot-completion detection +# (0 = disabled, use framebuffer fallback only) +luks-unlock-qemu target: + #!/usr/bin/bash + set -euo pipefail + PASSPHRASE="{{ luks-passphrase }}" + echo "Unlocking LUKS on installed QEMU VM..." + echo "Passphrase: ${PASSPHRASE}" + sudo python3 "src/luks-unlock.py" qemu \ + "{{ luks-qemu-monitor-installed }}" \ + "$PASSPHRASE" \ + "{{ luks-qemu-serial-installed }}" \ + "{{ luks-qemu-ssh-port-installed }}" + + for label in "Plymouth prompt" "Final boot"; do + key=$(echo "$label" | tr ' ' '-' | tr '[:upper:]' '[:lower:]') + bash "src/show-screenshot.sh" "/tmp/luks-screenshot-${key}.ppm" "$label" || true + done diff --git a/bootc-iso/scripts/configure_podman_storage.sh b/bootc-iso/scripts/configure_podman_storage.sh new file mode 100755 index 0000000..d565bd0 --- /dev/null +++ b/bootc-iso/scripts/configure_podman_storage.sh @@ -0,0 +1,70 @@ +#!/bin/bash +# SPDX-License-Identifier: Apache-2.0 +# Configure podman storage driver intelligently based on available filesystem +# Clears existing podman storage to avoid database mismatch errors + +set -eo pipefail + +# Stop podman if running +sudo podman rm -fa 2>/dev/null || true +sudo podman rmi -a 2>/dev/null || true + +# Clear existing podman storage database to avoid driver mismatch +# This is safe in CI where we start fresh each run +echo "Clearing podman storage database..." +if command -v podman &> /dev/null; then + sudo podman system reset -f 2>/dev/null || { + # Fallback if podman system reset isn't available + sudo rm -rf /var/lib/containers/storage.lock 2>/dev/null || true + sudo rm -rf /run/containers/storage.lock 2>/dev/null || true + echo "Warning: podman system reset not available, tried lock file cleanup as fallback" + } +else + echo "Podman not installed, skipping reset" +fi + +# Detect filesystem type at /var/lib/containers (where BTRFS loopback is mounted) +# Use findmnt to reliably detect filesystem (stat --file-system returns "ext2/ext3" for ext4) +if [ -d /var/lib/containers ]; then + FS_TYPE=$(findmnt -n -o FSTYPE -T /var/lib/containers 2>/dev/null || echo "unknown") +else + FS_TYPE=$(findmnt -n -o FSTYPE -T /var/lib 2>/dev/null || echo "unknown") +fi + +echo "Detected filesystem for /var/lib/containers: $FS_TYPE" + +# Choose driver based on filesystem (native drivers preferred for COW efficiency) +case "$FS_TYPE" in + btrfs) + DRIVER="btrfs" + echo "Using btrfs driver (native COW support on BTRFS filesystem)" + ;; + zfs) + DRIVER="zfs" + echo "Using zfs driver (native COW support on ZFS filesystem)" + ;; + ext4|ext3|ext2|xfs) + DRIVER="overlay" + echo "Using overlay driver (space-efficient on ext4/xfs)" + ;; + *) + DRIVER="vfs" + echo "Using vfs driver (fallback for $FS_TYPE)" + ;; +esac + +# Write storage.conf +echo "Configuring podman storage driver: $DRIVER" +GRAPHROOT="/var/lib/containers/storage" + +sudo bash -c "cat > /etc/containers/storage.conf" << CONF +[storage] +driver = "$DRIVER" +graphroot = "$GRAPHROOT" +runroot = "/run/containers/storage" +CONF + +# Verify configuration +echo "" +echo "=== Podman storage configuration ===" +sudo podman info | grep -A 5 "storage:" || sudo podman info | head -20 diff --git a/bootc-iso/src/build-iso.sh b/bootc-iso/src/build-iso.sh new file mode 100644 index 0000000..6fc1f65 --- /dev/null +++ b/bootc-iso/src/build-iso.sh @@ -0,0 +1,184 @@ +#!/usr/bin/bash +# build-iso.sh +# +# Creates a UEFI-bootable systemd-boot live ISO from pre-built components: +# — tar containing only kernel + EFI files from the rootfs +# — squashfs of the full live rootfs (built with correct UIDs +# via mksquashfs inside podman unshare) +# +# Boot architecture (no GRUB2, no shim): +# El Torito EFI entry → EFI/efi.img (FAT ESP image containing): +# EFI/BOOT/BOOTX64.EFI systemd-boot EFI binary (arch-detected) +# loader/loader.conf systemd-boot configuration +# loader/entries/bluefin-live.conf boot entry (kernel + initrd + cmdline) +# images/pxeboot/vmlinuz Bluefin kernel +# images/pxeboot/initrd.img dmsquash-live initramfs +# ISO9660 root: +# EFI/BOOT/BOOTX64.EFI EFI fallback path for Proxmox OVMF / Ventoy +# EFI/efi.img (also referenced by El Torito) +# images/pxeboot/* kernel/initramfs copies for loopback ISO boot tools +# boot/grub/loopback.cfg metadata for Ventoy/GRUB-style loopback boot +# LiveOS/squashfs.img squashfs of the full Bluefin live rootfs +# +# Live boot flow: +# UEFI firmware → El Torito → FAT ESP → systemd-boot → kernel+initramfs +# dmsquash-live: scans for CDLABEL=BLUEFIN_LIVE → mounts ISO → squashfs → overlayfs + +set -euo pipefail + +BOOT_TAR="${1:?Usage: build-iso.sh }" +SQUASHFS_SRC="${2:?Usage: build-iso.sh }" +OUTPUT_ISO="${3:?Usage: build-iso.sh }" +LABEL="BLUEFIN_LIVE" + +WORK=$(mktemp -d "${TMPDIR:-/tmp}/iso-build.XXXXXX") +trap "chmod -R u+rwX '${WORK}' 2>/dev/null; rm -rf '${WORK}'" EXIT + +BOOT_DIR="${WORK}/boot-files" +ISO_ROOT="${WORK}/iso-root" +ESP_STAGING="${WORK}/esp-staging" + +mkdir -p "${BOOT_DIR}" "${ISO_ROOT}/EFI" "${ISO_ROOT}/LiveOS" + +# ── Extract boot files (kernel, initramfs, systemd-boot EFI) ───────────────── +echo ">>> Extracting boot files..." +tar -xf "${BOOT_TAR}" -C "${BOOT_DIR}" --no-same-owner + +# ── Locate kernel ──────────────────────────────────────────────────────────── +kernel=$(ls "${BOOT_DIR}/usr/lib/modules" | sort -V | tail -1) +echo ">>> Kernel: ${kernel}" + +VMLINUZ="${BOOT_DIR}/usr/lib/modules/${kernel}/vmlinuz" +INITRD="${BOOT_DIR}/usr/lib/modules/${kernel}/initramfs.img" + +# Detect EFI binary: arm64 ships systemd-bootaa64.efi → BOOTAA64.EFI +# amd64 ships systemd-bootx64.efi → BOOTX64.EFI +BOOT_EFI_SRC="" +BOOT_EFI_DEST="" +for _candidate in \ + "systemd-bootaa64.efi:EFI/BOOT/BOOTAA64.EFI" \ + "systemd-bootx64.efi:EFI/BOOT/BOOTX64.EFI"; do + _src="${BOOT_DIR}/usr/lib/systemd/boot/efi/${_candidate%%:*}" + _dest="${_candidate##*:}" + if [[ -f "${_src}" ]]; then + BOOT_EFI_SRC="${_src}" + BOOT_EFI_DEST="${_dest}" + break + fi +done +[[ -n "${BOOT_EFI_SRC}" ]] || { echo "ERROR: no systemd-boot EFI binary found in boot-files tar"; exit 1; } + +for f in "${VMLINUZ}" "${INITRD}" "${BOOT_EFI_SRC}"; do + [[ -f "${f}" ]] || { echo "ERROR: missing ${f}"; exit 1; } +done +echo ">>> Kernel: $(du -sh "${VMLINUZ}" | cut -f1)" +echo ">>> Initramfs: $(du -sh "${INITRD}" | cut -f1)" +echo ">>> EFI: ${BOOT_EFI_SRC} → ${BOOT_EFI_DEST}" + +# ── Assemble the ESP staging directory ────────────────────────────────────── +# systemd-boot reads loader entries and kernel/initramfs exclusively from the +# FAT volume it was loaded from. Everything it needs must be in the ESP image. +mkdir -p \ + "${ESP_STAGING}/EFI/BOOT" \ + "${ESP_STAGING}/loader/entries" \ + "${ESP_STAGING}/images/pxeboot" + +cp "${BOOT_EFI_SRC}" "${ESP_STAGING}/${BOOT_EFI_DEST}" +cp "${VMLINUZ}" "${ESP_STAGING}/images/pxeboot/vmlinuz" +cp "${INITRD}" "${ESP_STAGING}/images/pxeboot/initrd.img" + +cat > "${ESP_STAGING}/loader/loader.conf" << 'EOF' +timeout 5 +default bluefin-live.conf +EOF + +# Kernel cmdline for dmsquash-live live boot: +# root=live:CDLABEL=... dmsquash-live: find the ISO by volume label +# rd.live.image enable dmsquash-live mode +# rd.live.overlay.overlayfs=1 use overlayfs (not device mapper) for the rw layer +# enforcing=0 disable SELinux enforcement (for live environment) +# console=ttyS0,115200n8 serial output on amd64 (16550/QEMU q35) — validation target +# console=ttyAMA0,115200n8 serial output on arm64 (PL011/QEMU virt) — validation target +cat > "${ESP_STAGING}/loader/entries/bluefin-live.conf" << EOF +title Bluefin Live +linux /images/pxeboot/vmlinuz +initrd /images/pxeboot/initrd.img +options root=live:CDLABEL=${LABEL} rd.live.image rd.live.overlay.overlayfs=1 enforcing=0 quiet console=ttyS0,115200n8 console=ttyAMA0,115200n8 +EOF + +# ── Create the FAT ESP image ────────────────────────────────────────────────── +# Size = kernel + initramfs + EFI binary + loader files + 32 MiB headroom +INITRD_MB=$(du -m "${INITRD}" | cut -f1) +VMLINUZ_MB=$(du -m "${VMLINUZ}" | cut -f1) +ESP_MB=$(( INITRD_MB + VMLINUZ_MB + 4 + 32 )) +ESP_IMG="${ISO_ROOT}/EFI/efi.img" + +echo ">>> Creating ${ESP_MB} MiB FAT ESP image..." +truncate -s "${ESP_MB}M" "${ESP_IMG}" +mkfs.fat -F 32 -n "ESP" "${ESP_IMG}" + +# Populate the FAT image using mtools — no loop mount required, works +# in unprivileged/restricted containers. +export MTOOLS_SKIP_CHECK=1 + +mmd -i "${ESP_IMG}" \ + ::/EFI \ + ::/EFI/BOOT \ + ::/loader \ + ::/loader/entries \ + ::/images \ + ::/images/pxeboot + +mcopy -i "${ESP_IMG}" "${ESP_STAGING}/${BOOT_EFI_DEST}" ::/"${BOOT_EFI_DEST}" +mcopy -i "${ESP_IMG}" "${ESP_STAGING}/loader/loader.conf" ::/loader/loader.conf +mcopy -i "${ESP_IMG}" "${ESP_STAGING}/loader/entries/bluefin-live.conf" ::/loader/entries/bluefin-live.conf +mcopy -i "${ESP_IMG}" "${ESP_STAGING}/images/pxeboot/vmlinuz" ::/images/pxeboot/vmlinuz +mcopy -i "${ESP_IMG}" "${ESP_STAGING}/images/pxeboot/initrd.img" ::/images/pxeboot/initrd.img + +# ── EFI fallback path on the ISO9660 root ──────────────────────────────────── +mkdir -p "${ISO_ROOT}/EFI/BOOT" +cp "${BOOT_EFI_SRC}" "${ISO_ROOT}/${BOOT_EFI_DEST}" +echo ">>> EFI fallback: ${BOOT_EFI_DEST} added to ISO root" + +# ── ISO-root kernel/initramfs and loopback metadata ────────────────────────── +mkdir -p "${ISO_ROOT}/images/pxeboot" "${ISO_ROOT}/boot/grub" +cp "${VMLINUZ}" "${ISO_ROOT}/images/pxeboot/vmlinuz" +cp "${INITRD}" "${ISO_ROOT}/images/pxeboot/initrd.img" +cat > "${ISO_ROOT}/boot/grub/loopback.cfg" << EOF +menuentry "Bluefin Live" { + linux /images/pxeboot/vmlinuz root=live:CDLABEL=${LABEL} rd.live.image rd.live.overlay.overlayfs=1 enforcing=0 quiet console=ttyS0,115200n8 console=ttyAMA0,115200n8 rd.bluefin.isofile=\${iso_path} + initrd /images/pxeboot/initrd.img +} +EOF +echo ">>> Loopback boot metadata added to ISO root" + +# ── Place the pre-built squashfs ───────────────────────────────────────────── +echo ">>> Copying squashfs..." +cp "${SQUASHFS_SRC}" "${ISO_ROOT}/LiveOS/squashfs.img" +echo ">>> Squashfs: $(du -sh "${ISO_ROOT}/LiveOS/squashfs.img" | cut -f1)" + +# ── Assemble the ISO with xorriso ──────────────────────────────────────────── +echo ">>> Assembling ISO..." +xorriso -as mkisofs \ + -iso-level 3 \ + -r \ + -J --joliet-long \ + -V "${LABEL}" \ + --efi-boot EFI/efi.img \ + -efi-boot-part \ + --efi-boot-image \ + -o "${OUTPUT_ISO}" \ + "${ISO_ROOT}" + +implantisomd5 "${OUTPUT_ISO}" 2>/dev/null || true + +# ── Verify protective MBR + GPT layout ─────────────────────────────────────── +echo ">>> Partition layout:" +xorriso -indev "${OUTPUT_ISO}" -report_system_area plain 2>/dev/null | \ + grep -E '^(System area|ISO image size|MBR|GPT|Partition)' || true +xorriso -indev "${OUTPUT_ISO}" -report_system_area plain 2>/dev/null | \ + grep 'System area summary' | grep -q 'protective' && \ + echo ">>> Protective MBR + GPT: OK" || \ + echo ">>> WARNING: protective MBR not found — USB may not boot on older firmware" + +echo ">>> Done: ${OUTPUT_ISO} ($(du -sh "${OUTPUT_ISO}" | cut -f1))" diff --git a/bootc-iso/src/configure-live.sh b/bootc-iso/src/configure-live.sh new file mode 100644 index 0000000..aa05d21 --- /dev/null +++ b/bootc-iso/src/configure-live.sh @@ -0,0 +1,361 @@ +#!/usr/bin/bash +# Live-environment setup for the Bluefin ISO installer image. +# +# Runs inside the final Bluefin container stage with: +# --cap-add sys_admin --security-opt label=disable +# +# At this point the initramfs has already been replaced (by the Debian +# initramfs-builder stage) with a dmsquash-live capable one. This script +# handles the runtime live-environment: user, GDM autologin, bootc-installer +# configuration + autostart, and Flatpak pre-installation. + +set -exo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + +# ── VERSION_ID ──────────────────────────────────────────────────────────────── +# Ensure VERSION_ID is present in os-release for image-builder and bootc tooling. +if grep -q '^VERSION_ID=' /usr/lib/os-release 2>/dev/null; then + sed -i 's/^VERSION_ID=.*/VERSION_ID=latest/' /usr/lib/os-release +else + echo 'VERSION_ID=latest' >> /usr/lib/os-release +fi + +# ── Live user ───────────────────────────────────────────────────────────────── +# Create a passwordless live user for the live session. +useradd --create-home --uid 1000 --user-group \ + --comment "Live User" liveuser || true +passwd --delete liveuser + +# Debug builds only: enable SSH so the live session is reachable for testing. +# Never enabled in production ISOs. +if [[ "${DEBUG:-0}" == "1" ]]; then + echo "liveuser:live" | chpasswd + + # Enable root login with a known password so hotfixes can be applied + # directly via `ssh root@` or `su -` without going through sudo. + passwd --unlock root + echo "root:root" | chpasswd + + # Enable sshd: the Bluefin preset marks sshd disabled, so a plain + # wants symlink gets overridden at first boot. A preset file in + # /etc/systemd/system-preset/ takes priority over /usr/lib and forces it on. + mkdir -p /etc/systemd/system-preset + echo "enable sshd.service" > /etc/systemd/system-preset/90-live-debug.preset + mkdir -p /etc/systemd/system/multi-user.target.wants + ln -sf /usr/lib/systemd/system/sshd.service \ + /etc/systemd/system/multi-user.target.wants/sshd.service + + cat >> /etc/ssh/sshd_config << 'SSHEOF' +PermitEmptyPasswords no +PasswordAuthentication yes +PermitRootLogin yes +SSHEOF + + # Open SSH through firewalld so port 22 is reachable from the host + mkdir -p /etc/firewalld/zones + cat > /etc/firewalld/zones/public.xml << 'FWEOF' + + + Public + + + + +FWEOF + + # Print SSH connection info to the serial console once the network is up. + cat > /usr/lib/systemd/system/debug-ssh-banner.service << 'BANNEREOF' +[Unit] +Description=Print SSH connection info to serial console +After=sshd.service network-online.target +Wants=network-online.target + +[Service] +Type=oneshot +ExecStart=/bin/bash -c '\ + IP=$(hostname -I | awk "{print \\$1}"); \ + echo ""; \ + echo "========================================"; \ + echo " DEBUG SSH READY"; \ + echo " ssh liveuser@${IP:-} (password: live)"; \ + echo " ssh root@${IP:-} (password: root)"; \ + echo "========================================"; \ + echo ""' +StandardOutput=journal+console + +[Install] +WantedBy=multi-user.target +BANNEREOF + systemctl enable debug-ssh-banner.service +fi + +# Give liveuser passwordless sudo so the live session is fully manageable +echo 'liveuser ALL=(ALL) NOPASSWD: ALL' > /etc/sudoers.d/liveuser +chmod 0440 /etc/sudoers.d/liveuser + +# Skip gnome-initial-setup in the live session so GNOME Shell starts directly +mkdir -p /home/liveuser/.config +touch /home/liveuser/.config/gnome-initial-setup-done +chown -R liveuser:liveuser /home/liveuser/.config + +# Remove gnome-tour desktop file so GNOME Shell can never launch it on the +# live ISO regardless of dconf state. +rm -f /usr/share/applications/org.gnome.Tour.desktop + +# Override the bootc-installer flatpak's desktop entry so it appears as +# "Bluefin Installer" with the bluefin icon instead of "bootc Installer (Devel)". +# On Fedora/ostree /usr/local is a symlink to /var/usrlocal — resolve it. +LOCAL_APPS=$(realpath /usr/local 2>/dev/null || echo /usr/local)/share/applications +mkdir -p "${LOCAL_APPS}" || { LOCAL_APPS=/usr/share/applications; mkdir -p "${LOCAL_APPS}"; } +cat > "${LOCAL_APPS}/org.bootcinstaller.Installer.Devel.desktop" << 'DESKTOPEOF' +[Desktop Entry] +Name=Bluefin Installer +Exec=/usr/bin/flatpak run --branch=master --arch=x86_64 --command=bootc-installer org.bootcinstaller.Installer.Devel +Icon=bluefin +Terminal=false +Type=Application +Categories=GTK;System;Settings; +StartupNotify=true +X-Flatpak=org.bootcinstaller.Installer.Devel +DESKTOPEOF + +# Suppress the GNOME Tour / "Welcome to Bluefin" dialog on first login. +mkdir -p /etc/dconf/db/distro.d /etc/dconf/db/distro.d/locks +cat > /etc/dconf/db/distro.d/50-live-iso << 'DCONFEOF' +[org/gnome/shell] +welcome-dialog-last-shown-version='999' +favorite-apps=['bluefin-installer.desktop', 'org.mozilla.firefox.desktop', 'org.gnome.Nautilus.desktop', 'org.gnome.Console.desktop'] + +[org/gnome/desktop/screensaver] +lock-enabled=false +idle-activation-enabled=false + +[org/gnome/desktop/session] +idle-delay=uint32 0 + +[org/gnome/settings-daemon/plugins/power] +sleep-inactive-ac-type='nothing' +sleep-inactive-battery-type='nothing' +sleep-inactive-ac-timeout=0 +sleep-inactive-battery-timeout=0 +power-button-action='nothing' +DCONFEOF + +cat > /etc/dconf/db/distro.d/locks/50-live-iso << 'LOCKSEOF' +/org/gnome/desktop/screensaver/lock-enabled +/org/gnome/desktop/screensaver/idle-activation-enabled +/org/gnome/desktop/session/idle-delay +/org/gnome/shell/favorite-apps +/org/gnome/settings-daemon/plugins/power/sleep-inactive-ac-type +/org/gnome/settings-daemon/plugins/power/sleep-inactive-battery-type +/org/gnome/settings-daemon/plugins/power/sleep-inactive-ac-timeout +/org/gnome/settings-daemon/plugins/power/sleep-inactive-battery-timeout +LOCKSEOF + +dconf update + +# Mask systemd sleep/suspend targets so the kernel never suspends regardless +# of what any userspace tool requests — belt-and-suspenders for the install. +systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target + +# ── GDM autologin ───────────────────────────────────────────────────────────── +mkdir -p /etc/gdm +cat > /etc/gdm/custom.conf << 'GDMEOF' +[daemon] +AutomaticLoginEnable=True +AutomaticLogin=liveuser +GDMEOF + +# ── /var/tmp tmpfs ──────────────────────────────────────────────────────────── +# The live overlayfs puts /var on a small RAM overlay. bootc needs substantial +# space in /var/tmp when staging an install; mount a dedicated tmpfs there. +cat > /usr/lib/systemd/system/var-tmp.mount << 'UNITEOF' +[Unit] +Description=Large tmpfs for /var/tmp in the live environment + +[Mount] +What=tmpfs +Where=/var/tmp +Type=tmpfs +Options=size=8G,nr_inodes=1m + +[Install] +WantedBy=local-fs.target +UNITEOF +systemctl enable var-tmp.mount + +# ── Default mounts for containers ───────────────────────────────────────────── +# Automatically bind-mount the read-only SquashFS cache at /usr/lib/containers/storage +# from the host into all container namespaces, allowing offline installation to work. +mkdir -p /etc/containers +cat > /etc/containers/mounts.conf << 'EOF' +/usr/lib/containers/storage:/usr/lib/containers/storage +EOF + + +# ── Live-ready marker service ───────────────────────────────────────────────── +# Prints BLUEFIN_LIVE_READY to the serial console after display-manager.service +# starts. CI boot verification greps for this token in the serial log. +cat > /usr/lib/systemd/system/live-ready.service << 'LREOF' +[Unit] +Description=Live environment ready marker +After=display-manager.service +Requires=display-manager.service + +[Service] +Type=oneshot +ExecStart=/bin/echo BLUEFIN_LIVE_READY +StandardOutput=tty +TTYPath=/dev/ttyS0 + +[Install] +WantedBy=multi-user.target +LREOF +systemctl enable live-ready.service + +# fisherman (bootc-installer backend) creates /var/fisherman-tmp and bind-mounts +# it to /var/tmp. Pre-create the directory so it exists at boot time. +mkdir -p /var/fisherman-tmp + +# ── Bluefin icon ────────────────────────────────────────────────────────────── +# Install icon in hicolor theme hierarchy for desktop integration +mkdir -p /usr/share/icons/hicolor/{16x16,24x24,32x32,48x48,64x64,128x128,256x256,512x512}/apps +for size in 16 24 32 48 64 128 256 512; do + install -Dm644 "$SCRIPT_DIR/icons/hicolor/${size}x${size}/apps/bluefin.png" \ + "/usr/share/icons/hicolor/${size}x${size}/apps/bluefin.png" +done +# Symlink 512×512 to pixmaps for compatibility +install -Dm644 "$SCRIPT_DIR/icons/hicolor/512x512/apps/bluefin.png" /usr/share/pixmaps/bluefin.png +gtk-update-icon-cache /usr/share/icons/hicolor/ + +# ── Installer tour images ───────────────────────────────────────────────────── +# The bootc-installer Flatpak has --filesystem=host so absolute paths are visible. +mkdir -p /usr/share/bootc-installer/images +install -Dm644 "$SCRIPT_DIR/images/bluefin.png" /usr/share/bootc-installer/images/bluefin.png + +# ── Installer configuration ─────────────────────────────────────────────────── +# The bootc-installer reads both overrides from /etc/bootc-installer/: +# images.json — locks the catalog to Bluefin only +# recipe.json — sets distro branding, tour slides, and install steps +mkdir -p /etc/bootc-installer +cp "$SCRIPT_DIR/etc/bootc-installer/images.json" /etc/bootc-installer/images.json +cp "$SCRIPT_DIR/etc/bootc-installer/recipe.json" /etc/bootc-installer/recipe.json +# Flag file read by the installer to activate live ISO mode. +touch /etc/bootc-installer/live-iso-mode + +# ── Installer autostart ─────────────────────────────────────────────────────── +# App ID differs between stable and dev channel builds. +INSTALLER_APP_ID="org.bootcinstaller.Installer" +[[ "${INSTALLER_CHANNEL:-stable}" == "dev" ]] && INSTALLER_APP_ID="org.bootcinstaller.Installer.Devel" + +# Create a wrapper script to handle the delay safely without desktop entry quoting issues +cat > /usr/bin/autostart-installer << EOF +#!/usr/bin/bash +sleep 5 +exec flatpak run --filesystem=/etc/bootc-installer:ro --env=VANILLA_CUSTOM_RECIPE=/etc/bootc-installer/recipe.json ${INSTALLER_APP_ID} +EOF +chmod +x /usr/bin/autostart-installer + +mkdir -p /etc/xdg/autostart +cat > /etc/xdg/autostart/tuna-installer.desktop << DTEOF +[Desktop Entry] +Name=Bluefin Installer +Exec=/usr/bin/autostart-installer +Icon=bluefin +Type=Application +X-GNOME-Autostart-enabled=true +DTEOF + +# A matching entry in /usr/share/applications/ lets GNOME Shell reference this +# app in the dock via favorite-apps. +mkdir -p /usr/share/applications +cat > /usr/share/applications/bluefin-installer.desktop << DTEOF +[Desktop Entry] +Name=Bluefin Installer +Comment=Install Bluefin to your computer +Exec=flatpak run --filesystem=/etc/bootc-installer:ro --env=VANILLA_CUSTOM_RECIPE=/etc/bootc-installer/recipe.json ${INSTALLER_APP_ID} +Icon=bluefin +Type=Application +Categories=System; +NoDisplay=false +DTEOF + +# ── Polkit rules for live installer ─────────────────────────────────────────── +# The installer's polkit action (org.tunaos.Installer.install) defaults to +# auth_admin. On the live ISO we want liveuser to install without any password +# prompt. Two complementary mechanisms are used for belt-and-suspenders: +# +# 1. Policy override: write the action definition directly with allow_active=yes +# so polkit approves it at the policy level before rules even run. +# +# 2. JS rule: belt-and-suspenders fallback that grants YES for liveuser. + +# fisherman symlink — installer calls /usr/local/bin/fisherman via pkexec +INSTALLER_APP_DIR=$(find /var/lib/flatpak/app/${INSTALLER_APP_ID} -name fisherman -type f 2>/dev/null | head -1 | xargs dirname 2>/dev/null || true) +if [ -n "$INSTALLER_APP_DIR" ]; then + mkdir -p /usr/local/bin + ln -sf "${INSTALLER_APP_DIR}/fisherman" /usr/local/bin/fisherman +fi + +# Policy file: allow any active session to run the installer without auth. +mkdir -p /usr/share/polkit-1/actions +cat > /usr/share/polkit-1/actions/org.bootcinstaller.Installer.policy << 'POLICYEOF' + + + + + Install an operating system to disk + Authentication is required to install an operating system + drive-harddisk + + no + no + yes + + /usr/local/bin/fisherman + true + + +POLICYEOF + +# JS rule: grant YES for liveuser on both custom + generic polkit exec actions. +mkdir -p /etc/polkit-1/rules.d +cat > /etc/polkit-1/rules.d/99-live-installer.rules << 'EOF' +polkit.addRule(function(action, subject) { + if ((action.id === "org.freedesktop.policykit.exec" || + action.id === "org.tunaos.Installer.install") && + subject.user === "liveuser" && subject.local) { + return polkit.Result.YES; + } +}); +EOF + +# ── Live network defaults ───────────────────────────────────────────────────── +# /etc/hostname is bind-mounted by the container runtime during builds; writing +# to it in a RUN step doesn't persist into the image layer. Use tmpfiles.d to +# create it at first boot instead. +mkdir -p /usr/lib/tmpfiles.d +echo 'f /etc/hostname 0644 - - - bluefin-live' > /usr/lib/tmpfiles.d/live-hostname.conf + +# ── Container storage ──────────────────────────────────────────────────────── +# Use overlay driver for space-efficient container operations. +# The embedded OCI in the squashfs is available via skopeo/podman pull +# from the registry. Overlay avoids VFS's full-image copy per layer. +# fuse-overlayfs (installed in Containerfile) handles overlay-on-overlay +# on kernels without native support (e.g. CentOS Stream 10 in bluefin-lts). +cat > /etc/containers/storage.conf << 'STOREOF' +[storage] +driver = "overlay" +runroot = "/run/containers/storage" +graphroot = "/var/lib/containers/storage" + +[storage.options] +additionalimagestores = [ + "/usr/lib/containers/storage" +] +STOREOF + +# fisherman handles scratch space, OCI export, and GPT partition setup natively. diff --git a/bootc-iso/src/dracut/95bluefin-isofile/bluefin-isofile.sh b/bootc-iso/src/dracut/95bluefin-isofile/bluefin-isofile.sh new file mode 100644 index 0000000..b478585 --- /dev/null +++ b/bootc-iso/src/dracut/95bluefin-isofile/bluefin-isofile.sh @@ -0,0 +1,94 @@ +#!/bin/sh +# Locate a Bluefin live ISO file on Ventoy/USB partitions and expose it as +# /dev/disk/by-label/BLUEFIN_LIVE so the standard dmsquash-live CDLABEL path works. + +LABEL="BLUEFIN_LIVE" +RUN_DIR="/run/initramfs/bluefin-isofile" +FOUND_MARKER="${RUN_DIR}/found" + +[ -e "/dev/disk/by-label/${LABEL}" ] && return 0 +[ -e "${FOUND_MARKER}" ] && return 0 + +mkdir -p "${RUN_DIR}" /dev/disk/by-label + +debug() { + echo "bluefin-isofile: $*" > /dev/kmsg 2>/dev/null || echo "bluefin-isofile: $*" +} + +iso_hint="" +for arg in $(cat /proc/cmdline); do + case "$arg" in + rd.bluefin.isofile=*|findiso=*|iso-scan/filename=*|rd.live.iso=*) + iso_hint="${arg#*=}" + ;; + esac +done + +try_iso() { + iso="$1" + [ -f "$iso" ] || return 1 + + loopdev=$(losetup --find --show --read-only "$iso" 2>/dev/null) || return 1 + iso_label=$(blkid -s LABEL -o value "$loopdev" 2>/dev/null || true) + + if [ "$iso_label" = "$LABEL" ]; then + ln -sf "$loopdev" "/dev/disk/by-label/${LABEL}" + : > "${FOUND_MARKER}" + udevadm settle 2>/dev/null || true + debug "using ISO file $iso via $loopdev" + /sbin/initqueue --settled --onetime --unique /sbin/dmsquash-live-root "$loopdev" + return 0 + fi + + losetup -d "$loopdev" 2>/dev/null || true + return 1 +} + +scan_mount() { + dev="$1" + base=$(basename "$dev") + mp="${RUN_DIR}/mnt-${base}" + mkdir -p "$mp" + + mount -o ro -t auto "$dev" "$mp" 2>/dev/null || return 1 + + if [ -n "$iso_hint" ]; then + case "$iso_hint" in + /*) + try_iso "${mp}${iso_hint}" && return 0 + ;; + *) + try_iso "${mp}/${iso_hint}" && return 0 + ;; + esac + fi + + # Fast common cases first. Avoid deep recursive searches in initramfs. + for iso in \ + "$mp"/bluefin*.iso \ + "$mp"/Bluefin*.iso \ + "$mp"/*.iso \ + "$mp"/ISO/*.iso \ + "$mp"/iso/*.iso \ + "$mp"/*/bluefin*.iso \ + "$mp"/*/*.iso + do + [ -e "$iso" ] || continue + try_iso "$iso" && return 0 + done + + umount "$mp" 2>/dev/null || true + return 1 +} + +# Prefer real partition nodes. Skip whole disks and optical devices here because +# direct ISO block devices are handled by the normal CDLABEL path above. +for dev in /dev/disk/by-label/* /dev/disk/by-id/*-part* /dev/sd*[0-9] /dev/vd*[0-9] /dev/nvme*n*p* /dev/mmcblk*p*; do + [ -b "$dev" ] || continue + [ -e "/dev/disk/by-label/${LABEL}" ] && return 0 + scan_mount "$dev" && return 0 +done + +# Keep dracut's initqueue waiting if neither the normal CDLABEL path nor the +# Ventoy/file-backed path is ready yet. +return 1 diff --git a/bootc-iso/src/dracut/95bluefin-isofile/module-setup.sh b/bootc-iso/src/dracut/95bluefin-isofile/module-setup.sh new file mode 100644 index 0000000..c02567e --- /dev/null +++ b/bootc-iso/src/dracut/95bluefin-isofile/module-setup.sh @@ -0,0 +1,23 @@ +#!/bin/bash +# Dracut module: support booting Bluefin ISO as a file from Ventoy-style media. + +check() { + return 0 +} + +depends() { + echo dmsquash-live + return 0 +} + +installkernel() { + instmods loop iso9660 squashfs overlay + instmods usb-storage xhci-pci xhci_hcd ehci-pci ehci_hcd uhci-hcd ohci-hcd + instmods sd_mod sr_mod virtio_blk virtio_pci virtio_scsi + instmods exfat vfat fat ntfs3 ext4 nls_cp437 nls_iso8859_1 nls_utf8 +} + +install() { + inst_multiple mount umount blkid losetup find grep sed mkdir ln readlink basename cat sleep udevadm + inst_hook initqueue 20 "$moddir/bluefin-isofile.sh" +} diff --git a/bootc-iso/src/etc/bootc-installer/images.json b/bootc-iso/src/etc/bootc-installer/images.json new file mode 100644 index 0000000..e18be56 --- /dev/null +++ b/bootc-iso/src/etc/bootc-installer/images.json @@ -0,0 +1,16 @@ +{ + "default_image": "ghcr.io/ublue-os/bluefin:stable", + "fallback_flatpaks": [], + "images": [ + { + "name": "Bluefin", + "imgref": "ghcr.io/ublue-os/bluefin:stable", + "desc": "Cloud-native developer workstation", + "icon": "resource:///org/bootcinstaller/Installer/images/bluefin.png", + "bootloader": "grub2", + "filesystem": "btrfs", + "needs_user_creation": true, + "flatpak_var_path": "var" + } + ] +} diff --git a/bootc-iso/src/etc/bootc-installer/recipe.json b/bootc-iso/src/etc/bootc-installer/recipe.json new file mode 100644 index 0000000..9979367 --- /dev/null +++ b/bootc-iso/src/etc/bootc-installer/recipe.json @@ -0,0 +1,57 @@ +{ + "log_file": "/var/log/bootc-installer.log", + "distro_name": "Bluefin", + "distro_logo": "resource:///org/bootcinstaller/Installer/images/bluefin.png", + "imgref": "ghcr.io/ublue-os/bluefin:stable", + "local_imgref": "containers-storage:ghcr.io/ublue-os/bluefin:stable", + "bootloader": "grub2", + "composeFsBackend": false, + "distroID": "bluefin", + "brewTap": "ublue-os/tap", + "tour": { + "welcome": { + "image": "/run/host/usr/share/bootc-installer/images/bluefin.png", + "title": "Welcome to Bluefin", + "description": "A cloud-native developer workstation built on Fedora Atomic Desktop technology." + }, + "features": { + "image": "/run/host/usr/share/bootc-installer/images/bluefin.png", + "title": "Developer-First", + "description": "Pre-configured with Brew, Devbox, Devcontainers, and cloud-native tools out of the box." + }, + "community": { + "image": "/run/host/usr/share/bootc-installer/images/bluefin.png", + "title": "Documentation & Community", + "description": "Find docs at docs.projectbluefin.io and join the community on Discord." + }, + "developer": { + "image": "/run/host/usr/share/bootc-installer/images/bluefin.png", + "title": "Always Up-to-Date", + "description": "Automatic updates via bootc. Your system stays current with the latest features and fixes." + }, + "completed": { + "image": "/run/host/usr/share/bootc-installer/images/bluefin.png", + "title": "Welcome to Bluefin", + "description": "Reboot into your new Bluefin system. Welcome aboard!" + } + }, + "steps": { + "welcome": { + "template": "welcome", + "protected": true + }, + "user": { + "template": "user" + }, + "image": { + "template": "image", + "protected": true + }, + "disk": { + "template": "disk" + }, + "encryption": { + "template": "encryption" + } + } +} diff --git a/bootc-iso/src/flatpaks b/bootc-iso/src/flatpaks new file mode 100644 index 0000000..5b0e6ca --- /dev/null +++ b/bootc-iso/src/flatpaks @@ -0,0 +1,45 @@ +# Bluefin system flatpaks +# Installed into the live squashfs at build time (committed to layer, not cache). +# Copied offline to the target by tuna-installer during installation. +# +# Note: org.bootcinstaller.Installer is installed separately via the GitHub +# Releases bundle (not on Flathub) earlier in build.sh. +# +# Format: one app ID per line, resolved from the flathub remote. +com.github.PintaProject.Pinta +com.github.tchx84.Flatseal +com.mattjakeman.ExtensionManager +com.ranfdev.DistroShelf +io.github.flattool.Ignition +io.github.flattool.Warehouse +io.github.kolunmi.Bazaar +io.gitlab.adhami3310.Impression +io.missioncenter.MissionCenter +it.mijorus.smile +org.gnome.Calculator +org.gnome.Calendar +org.gnome.Characters +org.gnome.Connections +org.gnome.Contacts +org.gnome.DejaDup +org.gnome.FileRoller +org.gnome.Firmware +org.gnome.Logs +org.gnome.Loupe +org.gnome.Maps +org.gnome.NautilusPreviewer +org.gnome.Papers +org.gnome.Showtime +org.gnome.SimpleScan +org.gnome.Snapshot +org.gnome.SoundRecorder +org.gnome.TextEditor +org.gnome.Weather +org.gnome.baobab +org.gnome.clocks +org.gnome.font-viewer +org.gtk.Gtk3theme.adw-gtk3 +org.gtk.Gtk3theme.adw-gtk3-dark +org.mozilla.Thunderbird +org.mozilla.firefox +page.tesk.Refine diff --git a/bootc-iso/src/icons/hicolor/128x128/apps/bluefin.png b/bootc-iso/src/icons/hicolor/128x128/apps/bluefin.png new file mode 100644 index 0000000000000000000000000000000000000000..53b2e8bb0797bdb0e2bfa45b880afba66aa1d3d6 GIT binary patch literal 4223 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 literal 0 HcmV?d00001 diff --git a/bootc-iso/src/icons/hicolor/24x24/apps/bluefin.png b/bootc-iso/src/icons/hicolor/24x24/apps/bluefin.png new file mode 100644 index 0000000000000000000000000000000000000000..73d91f8dd5d829d10dd0989a372b836a875824dd GIT binary patch literal 687 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 literal 0 HcmV?d00001 diff --git a/bootc-iso/src/icons/hicolor/32x32/apps/bluefin.png b/bootc-iso/src/icons/hicolor/32x32/apps/bluefin.png new file mode 100644 index 0000000000000000000000000000000000000000..865ade165d9ad0b3573920d6bc1835b551bba3cd GIT binary patch literal 946 zcmV;j15NyiP)E_R zDkLcEA&`0q3o?T2p$H2KB6*yYQy8B=&0<9vj6^n5Q5y!I0bMztLAby71w#KgN zsrYrZc4|~>)|laHZS+JYUK?zh~q7A+5q5FRYmI%l;aP~3toSd~ruXr0|~-S^-4 zy^+HpF2c9RXY}msJK6JHD+0wNJc!TnB%W_Iuo(gu*MeWZ*%*$uW8WwV58%Q&-KGAG zN`FBPcn64zA?uT93BkR@x5M!jGMMlrumUr(q9r=(L6 zMnZ`5p?9*oSp=%}ewsC-A*pC7*AlQ)P_HhR-WTayo(P}2`M7Y60jli2u$L7=~NrX=1jjG%QE?O+>ZODB+YeY zsedetVmY4PxXy@Bcn?UKy;ll-jsfh?Y*tH$)h;PQq*7dVWhk$5Q!or5KBa343;PgSSduXNPuDmwxyKadwiIg z?%mtFy}R48@nQeT&CHycGk4C+ne#DFKmi35P{98XwQ1U2oHkyCEyY;0Vo1$fZ0F`FdY~H+z;#ro&-(;w*c*iZ%B~sZZrWO0y}_R zKpD^l8~|nkhh1aG12>rZG2k?C1UP30)HO(PDAM&cP~lwZuG`ZPjb$r9D9iD4Nfo-s z)303hOTY$Gzv4GpI1*b0+yhJxM@koExfUQ*fHL4AU>WcXFeZTaF`(Dg?gnmjwNC@{ zOnoX)4OE#DM3lf&cCaAzS+Abd-E0CLaJ9RD1;F++ykDU8+hU(-htVf-5NI`h8-X}l z{}TXpYkR6e)c^@W%~hzCxd`As0q=bn4tz|~l6Z04hn4`w0!K|d?kN*}KZ_?OnCkxK zSBGy0=S+rcPJ#Che1le_=h3@0lB61VaVib{1ke%mV@D|~Kr28f6nQy_#}8fsTG1-= z9&jJv05fu#I1tJiXKE(_cCRcxmdi8)S)s$gkJw8$)DWToO2|odEP~AFakO>v!#LnM zQcdT>z-^v!j{-Hvw^iFLy`?F#5 zLkNum5G8eowk~N-!{3c|h(*9czX1aYFd3~5KWDe*K9r&@+BURPd>8G|Mw|Xh0Of?+ zdOO?WKKxDSAaES;CvdCZPrL%uqV;+OI@ST$lA{3AfD)h)5MaHbPo1$&NQz=yJ~=hSu5CpnCn7Jvf9u zMTOpsJ_Ox?1*FC|*`Nv?eI{JAQ$TqrAyL!L)P%O9*IMH3@Sebzz}x6BVjkLRtN|X+ zbk#0YqOI5yE?N;#u0j$Oy^om+U@c)O`eOIND?mH2+tjxK*8%sMg(S!h#lX$LW)Hm_ zbAeInG?~FBK>bc2NQFK@JC~{qf8<8GY_G@>twNHy7f!o*K^fTzQ~D+2jwy%X@9ZuD zdjM~cc1G!R6b0!lP{s%nz@~Wpj*g@*mf|nKdGsl?csoQ9RRRc^s!&=4sgTWS{gQAi zT)J540!gQp0%Za@3FVdpxDh14L{r+>Ur3(XMN>{n!+R3_ViE1vV+060a#aN=MkhAs zNX9ZTV3et!K&#Q+Y4{JI9nTzZhmAy)$e>lodk3ZiOVF2g0Wbya#;y131Qwz5;WNN5 zz*68hGsc}ew3zX4pjEH~Sd7SgdA(~SfJ735J^?p&nMJt2IH~ddW<$4*tpkTydav;~6f-$rwW6OuXy*$S!}Kp}q(#k_eF zK%vGErvqWKCa9wUEEyqhDg>ay>S^FkfRH$C0mCyw-UJYlzfo$nX`YW%lHB6QFrj#rG)Ii?DOpmEPs~`fmXR1mHge@O1QSJJ@Rg0000< KMNUMnLSTZ3gQo8Q literal 0 HcmV?d00001 diff --git a/bootc-iso/src/icons/hicolor/512x512/apps/bluefin.png b/bootc-iso/src/icons/hicolor/512x512/apps/bluefin.png new file mode 100644 index 0000000000000000000000000000000000000000..a5e4ee1806dee426f87187030645feaae3238a0c GIT binary patch literal 19212 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 literal 0 HcmV?d00001 diff --git a/bootc-iso/src/icons/hicolor/64x64/apps/bluefin.png b/bootc-iso/src/icons/hicolor/64x64/apps/bluefin.png new file mode 100644 index 0000000000000000000000000000000000000000..eef19c0adb72e6d5ebcaa2550987fde76efbc6b1 GIT binary patch literal 2071 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 literal 0 HcmV?d00001 diff --git a/bootc-iso/src/images/bluefin.svg b/bootc-iso/src/images/bluefin.svg new file mode 100644 index 0000000..75ee9e8 --- /dev/null +++ b/bootc-iso/src/images/bluefin.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/bootc-iso/src/install-flatpaks.sh b/bootc-iso/src/install-flatpaks.sh new file mode 100755 index 0000000..fdd2719 --- /dev/null +++ b/bootc-iso/src/install-flatpaks.sh @@ -0,0 +1,106 @@ +#!/usr/bin/bash +# Pre-install flatpaks into the live squashfs. +# +# Uses --mount=type=cache,target=/var/cache/flatpak-dl to persist the flatpak +# ostree repo across builds. On each run the script: +# 1. Seeds /var/lib/flatpak/repo from the build cache (warm start) +# 2. Reconciles to match /tmp/flatpaks-list (only deltas downloaded) +# 3. Saves the repo back to the cache for next build +# +# /tmp/flatpaks-list is COPYd by the Containerfile so it's always current. +# Requires network at build time; CAP_SYS_ADMIN for dbus. + +set -exo pipefail + +FLATPAK_CACHE="/var/cache/flatpak-dl" + +# overlayfs inside Podman builds doesn't support O_TMPFILE. /dev/shm would +# work but is only ~3.5 GB on GHA 7-GB runners — too small for GNOME Platform. +# The --mount=type=cache volume is a bind-mount from btrfs (supports O_TMPFILE) +# and has ~60 GB free, so use a subdirectory of it as TMPDIR instead. +mkdir -p "${FLATPAK_CACHE}/tmp" +export TMPDIR="${FLATPAK_CACHE}/tmp" +mkdir -p /run/dbus +dbus-daemon --system --fork --nopidfile +sleep 1 + +# ── Seed flatpak repo from build cache (warm start) ────────────────────────── +if [ -d "${FLATPAK_CACHE}/repo/refs" ]; then + echo "Seeding flatpak repo from build cache..." + rsync -a --ignore-existing "${FLATPAK_CACHE}/repo/" /var/lib/flatpak/repo/ || true + echo "Cache seed complete" +fi + +flatpak remote-add --system --if-not-exists flathub \ + https://dl.flathub.org/repo/flathub.flatpakrepo + +# bootc-installer bundle +# INSTALLER_CHANNEL controls which release tag to pull from: +# stable (default) → continuous (latest stable build from prod branch) +# dev → continuous-dev (latest dev build, tracks dev branch) +# Primary source: projectbluefin/bootc-installer (Project Bluefin's fork). +# Fallback: tuna-os/tuna-installer (upstream) if projectbluefin assets are unavailable. +# v2.5.0 includes fisherman v0.2.0 with fix for #38 (OCI cache mount on composefs/btrfs). +INSTALLER_REPO="projectbluefin/bootc-installer" +FALLBACK_REPO="tuna-os/tuna-installer" +RELEASE_TAG="continuous" +FLATPAK_FILENAME="org.bootcinstaller.Installer.flatpak" +if [[ "${INSTALLER_CHANNEL:-stable}" == "dev" ]]; then + RELEASE_TAG="continuous-dev" + FLATPAK_FILENAME="org.bootcinstaller.Installer.Devel.flatpak" +fi +if ! curl --retry 3 --fail --location \ + "https://github.com/${INSTALLER_REPO}/releases/download/${RELEASE_TAG}/${FLATPAK_FILENAME}" \ + -o /tmp/tuna-installer.flatpak 2>/dev/null; then + echo "Primary source unavailable, falling back to ${FALLBACK_REPO}..." + curl --retry 3 --fail --location \ + "https://github.com/${FALLBACK_REPO}/releases/download/${RELEASE_TAG}/${FLATPAK_FILENAME}" \ + -o /tmp/tuna-installer.flatpak +fi +INSTALLER_APP_ID="org.bootcinstaller.Installer" +[[ "${INSTALLER_CHANNEL:-stable}" == "dev" ]] && INSTALLER_APP_ID="org.bootcinstaller.Installer.Devel" + +flatpak install --system --noninteractive --bundle /tmp/tuna-installer.flatpak || \ + flatpak update --system --noninteractive "${INSTALLER_APP_ID}" +rm /tmp/tuna-installer.flatpak + +flatpak override --system --filesystem=/etc:ro "${INSTALLER_APP_ID}" + +# ── Reconcile Flathub apps against the wanted list ─────────────────────────── +# In debug mode, skip the full Flathub app list to keep builds fast. +# NOTE: Disabled to allow debug ISOs with full flatpak suite + SSH access +# if [[ "${DEBUG:-0}" == "1" ]]; then +# echo "DEBUG mode: skipping Flathub app list (installer-only ISO)" +# # Still save cache for the installer runtime +# echo "Saving flatpak repo to build cache..." +# mkdir -p "${FLATPAK_CACHE}" +# rsync -a --delete /var/lib/flatpak/repo/ "${FLATPAK_CACHE}/repo/" +# exit 0 +# fi + +readarray -t WANTED < <(grep -v '^[[:space:]]*#' /tmp/flatpaks-list | grep -v '^[[:space:]]*$') + +# Install or update everything in the list (--or-update = skip if current) +# --no-related skips locale packs and debug symbols (~3 GB uncompressed) +flatpak install --system --noninteractive --no-related --or-update flathub "${WANTED[@]}" + +# Remove any system app that is no longer in the wanted list +readarray -t INSTALLED < <(flatpak list --app --system --columns=application 2>/dev/null || true) +for app in "${INSTALLED[@]}"; do + # Keep the installer regardless (stable or devel app ID) + [[ "$app" == "org.bootcinstaller.Installer" ]] && continue + [[ "$app" == "org.bootcinstaller.Installer.Devel" ]] && continue + if [[ ! " ${WANTED[*]} " =~ " ${app} " ]]; then + echo "Removing dropped flatpak: $app" + flatpak uninstall --system --noninteractive "$app" || true + fi +done + +# Prune unused runtimes left behind by removals +flatpak uninstall --system --noninteractive --unused || true + +# ── Save flatpak repo to build cache for next build ────────────────────────── +echo "Saving flatpak repo to build cache..." +mkdir -p "${FLATPAK_CACHE}" +rsync -a --delete /var/lib/flatpak/repo/ "${FLATPAK_CACHE}/repo/" +echo "Cache updated" diff --git a/bootc-iso/src/luks-unlock.py b/bootc-iso/src/luks-unlock.py new file mode 100644 index 0000000..1fdf735 --- /dev/null +++ b/bootc-iso/src/luks-unlock.py @@ -0,0 +1,534 @@ +#!/usr/bin/env python3 +""" +Automate LUKS passphrase entry for a VM booting with Plymouth. + +Plymouth renders the passphrase prompt on the EFI framebuffer (not the serial +console), so we cannot detect it via serial output. Instead we detect the +Plymouth prompt by analysing QEMU screendumps (PPM files): + + - Plymouth passphrase prompt is a static, nearly all-black screen. + - We wait for the screendump MD5 hash to stabilise (stop changing) after + the framebuffer has first shown any non-zero content (OVMF/boot rendered). + - Then inject keystrokes via virsh send-key (libvirt) or QEMU HMP sendkey. + +Usage: + libvirt mode: luks-unlock.py libvirt + qemu mode: luks-unlock.py qemu + +Exit codes: + 0 — passphrase sent and boot succeeded (display re-stabilised after unlock) + 1 — error (timed out, passphrase prompt never appeared, etc.) + 2 — passphrase sent but boot resulted in emergency shell (issue #270 reproduced) +""" + +import hashlib +import os +import subprocess +import sys +import time + + +# ── Shared constants ────────────────────────────────────────────────────────── + +POLL_INTERVAL = 3 # seconds between screenshot polls +PLYMOUTH_WAIT = 10 # seconds to wait after display goes blank before sending keys +PROMPT_DEADLINE = 300 # seconds to wait for Plymouth to take over +BOOT_DEADLINE = 900 # seconds to wait for successful boot after passphrase + +# Headless QEMU (-display none) often keeps the framebuffer all-black after +# LUKS unlock while GRUB2 and Plymouth run. If the screen hash has not +# changed within this many seconds of the passphrase being sent, we assume +# the passphrase was accepted and the system is booting silently. +DARK_SCREEN_OVERRIDE_S = 90 + + +# ── Libvirt helpers ─────────────────────────────────────────────────────────── + +def virsh_screenshot_size(vm: str, path: str) -> int: + r = subprocess.run(["virsh", "screenshot", vm, path], capture_output=True) + if r.returncode != 0: + return 0 + try: + return os.path.getsize(path) + except OSError: + return 0 + + +def virsh_send_passphrase(vm: str, passphrase: str): + key_map = { + c: f"KEY_{c.upper()}" for c in "abcdefghijklmnopqrstuvwxyz" + } + key_map.update({str(i): f"KEY_{i}" for i in range(10)}) + key_map["-"] = "KEY_MINUS" + key_map["_"] = "KEY_MINUS" + key_map[" "] = "KEY_SPACE" + + for ch in passphrase: + key = key_map.get(ch) + if key is None: + print(f"[luks-unlock] WARNING: no key mapping for {ch!r}", file=sys.stderr) + continue + subprocess.run( + ["virsh", "send-key", vm, "--codeset", "linux", key], + capture_output=True, + ) + time.sleep(0.08) + subprocess.run( + ["virsh", "send-key", vm, "--codeset", "linux", "KEY_ENTER"], + capture_output=True, + ) + + +def virsh_dhcp_ip(mac: str) -> str: + r = subprocess.run( + ["virsh", "net-dhcp-leases", "default"], + capture_output=True, text=True, + ) + for line in r.stdout.splitlines(): + if mac.lower() in line.lower(): + for part in line.split(): + if "/" in part and "." in part: + return part.split("/")[0] + return "" + + +# ── QEMU monitor helpers ────────────────────────────────────────────────────── + +def qemu_screendump(sock: str, path: str) -> tuple: + """Return (brightness, md5_hash) for the screendump, or (-1, '') on error. + + PPM files are always the same byte length regardless of content, so we + analyse pixel values rather than file size. + + brightness — average sampled pixel value (0-255). + QEMU uninitialized: all zeros → 0.0 + OVMF/bootloader: dim text on black → typically 0.5–5 + Plymouth prompt: nearly all-black → typically 0.5–2, STABLE + GDM/GNOME: colourful UI → typically higher + + md5_hash — MD5 of the full PPM file. Used to detect when the display + has stopped changing (Plymouth is waiting for passphrase input). + """ + subprocess.run( + ["socat", "-", f"UNIX-CONNECT:{sock}"], + input=f"screendump {path}\n".encode(), + capture_output=True, + timeout=5, + ) + # Brief pause so QEMU can finish writing the PPM before we read it + time.sleep(0.5) + try: + data = open(path, "rb").read() + except OSError: + return -1, "" + md5 = hashlib.md5(data).hexdigest() + # Parse PPM header: "P6\n \n255\n" + try: + header_end = data.index(b"255\n") + 4 + except ValueError: + return -1, "" + pixel_data = data[header_end:] + if not pixel_data: + return -1, "" + # Sample every 100th byte for speed (each pixel = 3 bytes R,G,B) + sampled = pixel_data[::100] + return sum(sampled) / len(sampled), md5 + + +def qemu_send_passphrase(sock: str, passphrase: str): + # QEMU HMP sendkey takes individual key names (one per invocation). + # Keys are sent one character at a time with a small delay. + key_map = {c: c for c in "abcdefghijklmnopqrstuvwxyz0123456789"} + key_map["-"] = "minus" + key_map["_"] = "shift-minus" + key_map[" "] = "spc" + + def _sendkey(key: str): + subprocess.run( + ["socat", "-", f"UNIX-CONNECT:{sock}"], + input=f"sendkey {key}\n".encode(), + capture_output=True, + timeout=5, + ) + + for ch in passphrase: + key = key_map.get(ch) + if key is None: + print(f"[luks-unlock] WARNING: no key mapping for {ch!r}", file=sys.stderr) + continue + _sendkey(key) + time.sleep(0.1) + _sendkey("ret") + + +def qemu_check_serial(serial_log: str) -> str: + """Return 'plymouth', 'gdm', 'emergency', or '' if no marker yet. + + Checks for systemd unit messages that appear on the serial console when the + installed system has console=ttyS0 in its kernel cmdline. + Falls back gracefully to '' when serial output is absent. + """ + import re + try: + raw = open(serial_log).read() + except OSError: + return "" + # Strip ANSI escape codes and collapse whitespace so that systemd status + # lines like " OK ] Started \ngdm.service\n- GNOME Display…" + # become searchable as a single string. + content = re.sub(r'\x1b\[[0-9;]*[A-Za-z]', '', raw) + content_flat = ' '.join(content.split()) + if "emergency mode" in content or "emergency shell" in content: + return "emergency" + # systemd serial output (ANSI-stripped, whitespace-collapsed): + # "OK ] Started gdm.service - GNOME Display Manager." + if "Started gnome-initial-setup" in content_flat: + return "gnome-initial-setup" + if "Started gdm.service" in content_flat or "Started GNOME Display Manager" in content_flat: + return "gdm" + # Plymouth passphrase prompt — no ANSI codes, plain text on serial. + if "Please enter passphrase for disk" in raw: + return "plymouth" + return "" + + +# ── Mode implementations ────────────────────────────────────────────────────── + +def run_libvirt(vm: str, passphrase: str, mac: str): + snap = "/tmp/luks-unlock-snap.png" + seen_content = False + + print(f"[luks-unlock] libvirt mode — watching {vm} for Plymouth takeover...", flush=True) + deadline = time.time() + PROMPT_DEADLINE + + while time.time() < deadline: + size = virsh_screenshot_size(vm, snap) + print(f"[luks-unlock] screenshot: {size}B", flush=True) + + if not seen_content and size > 4096: + seen_content = True + print("[luks-unlock] Boot content visible (OVMF/bootloader)", flush=True) + + if seen_content and size <= 4096: + print( + f"[luks-unlock] Plymouth has the display — waiting {PLYMOUTH_WAIT}s...", + flush=True, + ) + time.sleep(PLYMOUTH_WAIT) + print("[luks-unlock] Sending passphrase via virsh send-key...", flush=True) + virsh_send_passphrase(vm, passphrase) + print("[luks-unlock] Passphrase sent — waiting for boot...", flush=True) + break + + time.sleep(POLL_INTERVAL) + else: + print("[luks-unlock] ERROR: Plymouth takeover never detected", file=sys.stderr) + sys.exit(1) + + deadline = time.time() + BOOT_DEADLINE + while time.time() < deadline: + ip = virsh_dhcp_ip(mac) + if ip: + print(f"[luks-unlock] RESULT: boot succeeded — guest IP {ip}", flush=True) + sys.exit(0) + time.sleep(5) + + print("[luks-unlock] WARNING: passphrase sent but no DHCP lease within timeout", file=sys.stderr) + sys.exit(2) + + +def ssh_reachable(port: int, timeout: int = 5) -> bool: + """Return True if sshd on localhost:port is accepting TCP connections. + + Checks TCP reachability only — does not require auth or a configured user. + An SSH banner in the response means the daemon is up and the system booted. + """ + import socket + try: + with socket.create_connection(("127.0.0.1", port), timeout=timeout) as s: + banner = s.recv(64) + return banner.startswith(b"SSH-") + except OSError: + return False + + +def run_qemu(monitor_sock: str, passphrase: str, serial_log: str, ssh_port: int = 0): + snap = "/tmp/luks-unlock-snap.ppm" + + # Plymouth detection strategy + # ---------------------------- + # QEMU with -display none renders very dim (brightness 0–5 for all phases). + # We cannot distinguish OVMF from Plymouth by absolute brightness, so we use + # two criteria instead: + # + # 1. had_content: at least one poll returned brightness > 0.5, meaning the + # VM has started rendering something (rules out the all-zeros framebuffer + # right after QEMU starts). + # + # 2. hash stability: the screendump MD5 has not changed for STABLE_POLLS + # consecutive polls. Plymouth passphrase prompt is a static screen + # (no animation) so it stabilises quickly; OVMF and early boot are + # actively changing. + CONTENT_THRESHOLD = 0.5 # any non-zero rendering + STABLE_POLLS = 2 # consecutive identical-hash polls → Plymouth waiting + # (≥ 6 s at POLL_INTERVAL=3) + + print(f"[luks-unlock] qemu mode — watching monitor {monitor_sock}...", flush=True) + deadline = time.time() + PROMPT_DEADLINE + + had_content = False + stable_count = 0 + prev_hash = "" + + while time.time() < deadline: + # Primary path: detect Plymouth passphrase prompt via serial log. + # With console=tty0 console=ttyS0 in the BLS entry, Plymouth writes + # the prompt to serial. Input still comes from tty0, so sendkey works. + serial_result = qemu_check_serial(serial_log) + if serial_result == "plymouth": + print("[luks-unlock] Plymouth passphrase prompt detected via serial", flush=True) + brightness, md5 = qemu_screendump(monitor_sock, snap) + prev_hash = md5 # anchor passphrase_hash so post-passphrase screen_changed is accurate + try: + import shutil + shutil.copy2(snap, "/tmp/luks-screenshot-plymouth.ppm") + except OSError: + pass + print(f"[luks-unlock] Waiting {PLYMOUTH_WAIT}s for Plymouth to settle...", flush=True) + time.sleep(PLYMOUTH_WAIT) + print("[luks-unlock] Sending passphrase via QEMU monitor sendkey...", flush=True) + qemu_send_passphrase(monitor_sock, passphrase) + print("[luks-unlock] Passphrase sent — watching for boot...", flush=True) + break + + brightness, md5 = qemu_screendump(monitor_sock, snap) + print(f"[luks-unlock] screendump brightness={brightness:.2f} hash={md5[:8]}", flush=True) + + if brightness < 0: + # Failed to read/parse screendump — socket not ready yet + stable_count = 0 + time.sleep(POLL_INTERVAL) + continue + + if not had_content and brightness > CONTENT_THRESHOLD: + had_content = True + print(f"[luks-unlock] VM is rendering (brightness {brightness:.2f})", flush=True) + + # Track hash stability only after the framebuffer has any content + if had_content: + if md5 == prev_hash: + stable_count += 1 + else: + stable_count = 0 + prev_hash = md5 + + # Fallback: detect Plymouth via framebuffer stability (no serial console) + if had_content and stable_count >= STABLE_POLLS: + print( + f"[luks-unlock] Plymouth prompt stable" + f" (brightness={brightness:.2f}, {stable_count} identical polls)", + flush=True, + ) + # Save a copy of the Plymouth screendump for CI diagnostics + try: + import shutil + shutil.copy2(snap, "/tmp/luks-screenshot-plymouth.ppm") + except OSError: + pass + print(f"[luks-unlock] Waiting {PLYMOUTH_WAIT}s for Plymouth to settle...", flush=True) + time.sleep(PLYMOUTH_WAIT) + print("[luks-unlock] Sending passphrase via QEMU monitor sendkey...", flush=True) + qemu_send_passphrase(monitor_sock, passphrase) + print("[luks-unlock] Passphrase sent — watching for boot...", flush=True) + break + + time.sleep(POLL_INTERVAL) + else: + print("[luks-unlock] ERROR: Plymouth takeover never detected", file=sys.stderr) + sys.exit(1) + + # After passphrase: watch for the screen to change from Plymouth (passphrase + # accepted → Plymouth clears → boot continues) and check serial for emergency + # shell (still useful for catching issue #270 even without ttyS0). + deadline = time.time() + BOOT_DEADLINE + passphrase_time = time.time() + passphrase_hash = prev_hash # Plymouth hash at time of passphrase send + screen_changed = False + gnome_bright_count = 0 + emergency_stable_count = 0 + + + while time.time() < deadline: + result = qemu_check_serial(serial_log) + if result == "emergency": + print("[luks-unlock] RESULT: emergency shell — issue #270 reproduced", flush=True) + sys.exit(2) + + # SSH success path: if caller provided a port, test TCP reachability to + # detect sshd banner — no auth needed, just "daemon is up = boot done". + # Wins reliably when the installed system starts sshd but lacks + # console=ttyS0 (so no serial markers reach the log). + if ssh_port and ssh_reachable(ssh_port): + print(f"[luks-unlock] RESULT: boot succeeded (sshd banner on port {ssh_port})", + flush=True) + print("[luks-unlock] Waiting 20s for GDM/desktop to fully render...", flush=True) + time.sleep(20) + try: + import shutil + qemu_screendump(monitor_sock, snap) + shutil.copy2(snap, "/tmp/luks-screenshot-final.ppm") + except OSError: + pass + sys.exit(0) + + # Dark-screen override: headless QEMU (-display none) often keeps the + # framebuffer all-black during GRUB2 + Plymouth even after a successful + # LUKS unlock. The passphrase_hash == post-passphrase hash so + # screen_changed never flips and the brightness check never runs. + # + # When the screen stays dark for DARK_SCREEN_OVERRIDE_S seconds: + # - With SSH port: do nothing. We just keep looping and polling SSH. + # - Without SSH port: exit 0 now. If the passphrase was wrong Plymouth + # would have re-prompted; silence = passphrase accepted = boot proceeding. + elapsed_since_passphrase = time.time() - passphrase_time + if not screen_changed and elapsed_since_passphrase > DARK_SCREEN_OVERRIDE_S: + if not ssh_port: + print( + f"[luks-unlock] Dark-screen override: screen unchanged for " + f"{int(elapsed_since_passphrase)}s and no SSH port configured — assuming boot succeeded", + flush=True, + ) + sys.exit(0) + + + brightness, md5 = qemu_screendump(monitor_sock, snap) + print(f"[luks-unlock] post-passphrase brightness={brightness:.2f} hash={md5[:8]}", + flush=True) + + if md5 != passphrase_hash and not screen_changed: + screen_changed = True + print( + "[luks-unlock] Screen changed after passphrase" + " — LUKS accepted, boot proceeding", + flush=True, + ) + + # Primary success path: serial log confirms gnome-initial-setup or GDM. + # gnome-initial-setup fires after GDM — screenshot taken immediately. + # If only GDM is seen, wait 30s as a fallback in case g-i-s is slow. + if result == "gnome-initial-setup": + print("[luks-unlock] gnome-initial-setup started (serial confirmed) — waiting 15s to render UI", flush=True) + time.sleep(15) + brightness, md5 = qemu_screendump(monitor_sock, snap) + print(f"[luks-unlock] RESULT: boot succeeded (g-i-s confirmed via serial, brightness={brightness:.2f})", flush=True) + elif result == "gdm": + print( + "[luks-unlock] GDM started — waiting 30s for gnome-initial-setup...", + flush=True, + ) + time.sleep(30) + brightness, md5 = qemu_screendump(monitor_sock, snap) + print( + f"[luks-unlock] RESULT: boot succeeded" + f" (GDM confirmed via serial, brightness={brightness:.2f})", + flush=True, + ) + if result in ("gnome-initial-setup", "gdm"): + try: + import shutil + shutil.copy2(snap, "/tmp/luks-screenshot-final.ppm") + except OSError: + pass + sys.exit(0) + + # Fallback: no serial console (console=ttyS0 absent). Use framebuffer + # brightness to distinguish GDM from emergency shell. + # GDM re-renders continuously (cursor blink, animations, clock), so we + # cannot require identical hashes. Instead, we detect GDM by verifying + # the screen remains bright for multiple consecutive polls. + # For the emergency shell, which is static and dark, we require identical + # hashes and low brightness. + GNOME_THRESHOLD = 1.8 + GNOME_BRIGHT_POLLS = 2 # Screen remains bright for 2 polls (~10s) + EMERGENCY_STABLE_POLLS = 3 # Screen remains stable and dark for 3 polls (~15s) + + if screen_changed: + if brightness > GNOME_THRESHOLD: + gnome_bright_count += 1 + else: + gnome_bright_count = 0 + + if md5 == prev_hash and brightness <= GNOME_THRESHOLD: + emergency_stable_count += 1 + else: + emergency_stable_count = 0 + + if gnome_bright_count >= GNOME_BRIGHT_POLLS: + print( + f"[luks-unlock] RESULT: boot succeeded" + f" (framebuffer bright for {gnome_bright_count} polls," + f" brightness={brightness:.2f})", + flush=True, + ) + print("[luks-unlock] Waiting 25s for GDM/desktop to fully render...", flush=True) + time.sleep(25) + try: + import shutil + qemu_screendump(monitor_sock, snap) + shutil.copy2(snap, "/tmp/luks-screenshot-final.ppm") + except OSError: + pass + sys.exit(0) + + if emergency_stable_count >= EMERGENCY_STABLE_POLLS: + print( + f"[luks-unlock] RESULT: emergency shell suspected" + f" (framebuffer stable and dark for {emergency_stable_count} polls," + f" brightness={brightness:.2f})", + flush=True, + ) + try: + import shutil + shutil.copy2(snap, "/tmp/luks-screenshot-final.ppm") + except OSError: + pass + sys.exit(2) + + prev_hash = md5 + time.sleep(5) + + print("[luks-unlock] WARNING: passphrase sent but boot did not complete within timeout", + file=sys.stderr) + sys.exit(2) + + +# ── Entry point ─────────────────────────────────────────────────────────────── + +def main(): + if len(sys.argv) < 2: + print(__doc__, file=sys.stderr) + sys.exit(1) + + mode = sys.argv[1] + + if mode == "libvirt": + if len(sys.argv) < 5: + print("Usage: luks-unlock.py libvirt ", file=sys.stderr) + sys.exit(1) + run_libvirt(sys.argv[2], sys.argv[3], sys.argv[4]) + + elif mode == "qemu": + if len(sys.argv) < 5: + print("Usage: luks-unlock.py qemu [ssh-port]", + file=sys.stderr) + sys.exit(1) + ssh_port = int(sys.argv[5]) if len(sys.argv) >= 6 else 0 + run_qemu(sys.argv[2], sys.argv[3], sys.argv[4], ssh_port=ssh_port) + + else: + print(f"Unknown mode: {mode!r}. Use 'libvirt' or 'qemu'.", file=sys.stderr) + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/bootc-iso/src/show-screenshot.sh b/bootc-iso/src/show-screenshot.sh new file mode 100755 index 0000000..aaf9c8a --- /dev/null +++ b/bootc-iso/src/show-screenshot.sh @@ -0,0 +1,32 @@ +#!/usr/bin/bash +# Display a PPM screendump inline in terminals that support it. +# Usage: show-screenshot.sh