kubesolo-os/test/lib/qemu-helpers.sh

#!/bin/bash
# qemu-helpers.sh — Shared functions for QEMU-based tests
# Source this file from test scripts: . "$(dirname "$0")/../lib/qemu-helpers.sh"

# extract_kernel_from_iso <iso-path> <extract-dir>
# Sets VMLINUZ and INITRAMFS variables on success
# Falls back to build/rootfs-work/ if available
extract_kernel_from_iso() {
    local iso="$1"
    local extract_dir="$2"
    local project_root="${PROJECT_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
    local rootfs_dir="${ROOTFS_DIR:-$project_root/build/rootfs-work}"

    VMLINUZ=""
    INITRAMFS=""

    # Prefer build artifacts (no extraction needed)
    if [ -f "$rootfs_dir/vmlinuz" ] && [ -f "$rootfs_dir/kubesolo-os.gz" ]; then
        VMLINUZ="$rootfs_dir/vmlinuz"
        INITRAMFS="$rootfs_dir/kubesolo-os.gz"
        echo "    Using kernel/initramfs from build directory"
        return 0
    fi

    local extracted=0

    echo "    Extracting kernel/initramfs from ISO..."

    # Method 1: bsdtar (ships with macOS, libarchive-tools on Linux)
    if [ $extracted -eq 0 ] && command -v bsdtar >/dev/null 2>&1; then
        if bsdtar -xf "$iso" -C "$extract_dir" boot/vmlinuz boot/kubesolo-os.gz 2>/dev/null; then
            echo "    Extracted via bsdtar"
            extracted=1
        fi
    fi

    # Method 2: isoinfo (genisoimage/cdrtools)
    if [ $extracted -eq 0 ] && command -v isoinfo >/dev/null 2>&1; then
        mkdir -p "$extract_dir/boot"
        isoinfo -i "$iso" -x "/BOOT/VMLINUZ;1" > "$extract_dir/boot/vmlinuz" 2>/dev/null || true
        isoinfo -i "$iso" -x "/BOOT/KUBESOLO-OS.GZ;1" > "$extract_dir/boot/kubesolo-os.gz" 2>/dev/null || true
        if [ -s "$extract_dir/boot/vmlinuz" ] && [ -s "$extract_dir/boot/kubesolo-os.gz" ]; then
            echo "    Extracted via isoinfo"
            extracted=1
        else
            rm -f "$extract_dir/boot/vmlinuz" "$extract_dir/boot/kubesolo-os.gz"
        fi
    fi

    # Method 3: loop mount (Linux only, may need root)
    if [ $extracted -eq 0 ] && [ "$(uname)" = "Linux" ]; then
        local iso_mount="$extract_dir/mnt"
        mkdir -p "$iso_mount"
        if mount -o loop,ro "$iso" "$iso_mount" 2>/dev/null; then
            mkdir -p "$extract_dir/boot"
            cp "$iso_mount/boot/vmlinuz" "$extract_dir/boot/" 2>/dev/null || true
            cp "$iso_mount/boot/kubesolo-os.gz" "$extract_dir/boot/" 2>/dev/null || true
            umount "$iso_mount" 2>/dev/null || true
            if [ -f "$extract_dir/boot/vmlinuz" ] && [ -f "$extract_dir/boot/kubesolo-os.gz" ]; then
                echo "    Extracted via loop mount"
                extracted=1
            fi
        fi
    fi

    if [ $extracted -eq 0 ]; then
        echo "ERROR: Failed to extract kernel/initramfs from ISO."
        echo "  Install one of: bsdtar (libarchive-tools), isoinfo (genisoimage), or run as root for loop mount."
        return 1
    fi

    VMLINUZ="$extract_dir/boot/vmlinuz"
    INITRAMFS="$extract_dir/boot/kubesolo-os.gz"
    return 0
}

# detect_kvm — prints "-enable-kvm" if KVM available, empty string otherwise
detect_kvm() {
    if [ -w /dev/kvm ] 2>/dev/null; then
        echo "-enable-kvm"
    fi
}

# wait_for_boot <serial-log> <qemu-pid> [timeout]
# Waits for "KubeSolo is running" marker in serial log.
# Returns 0 on success, 1 on timeout/failure.
# Sets BOOT_ELAPSED to seconds taken.
wait_for_boot() {
    local serial_log="$1"
    local qemu_pid="$2"
    local timeout="${3:-180}"

    BOOT_ELAPSED=0
    while [ "$BOOT_ELAPSED" -lt "$timeout" ]; do
        if grep -q "\[kubesolo-init\] \[OK\] KubeSolo is running" "$serial_log" 2>/dev/null; then
            echo ""
            echo "    Boot completed in ${BOOT_ELAPSED}s"
            return 0
        fi
        if ! kill -0 "$qemu_pid" 2>/dev/null; then
            echo ""
            echo "==> FAIL: QEMU exited prematurely"
            tail -20 "$serial_log" 2>/dev/null
            return 1
        fi
        sleep 2
        BOOT_ELAPSED=$((BOOT_ELAPSED + 2))
        printf "\r    Elapsed: %ds / %ds" "$BOOT_ELAPSED" "$timeout"
    done
    echo ""
    echo "==> FAIL: Boot did not complete within ${timeout}s"
    tail -30 "$serial_log" 2>/dev/null
    return 1
}

# fetch_kubeconfig <host-port> <output-file>
# Fetches kubeconfig via HTTP from the given host port.
# The port should be the QEMU-forwarded host port mapped to guest port 8080.
# Returns 0 on success, 1 on failure.
fetch_kubeconfig() {
    local port="$1"
    local output_file="$2"

    echo "    Fetching kubeconfig from http://localhost:${port}..."
    local j=0
    while [ $j -lt 30 ]; do
        if curl -sf "http://localhost:${port}" -o "$output_file" 2>/dev/null; then
            if [ -s "$output_file" ] && grep -q "server:" "$output_file" 2>/dev/null; then
                echo "    Kubeconfig fetched successfully"
                return 0
            fi
        fi
        sleep 2
        j=$((j + 1))
    done

    echo "==> FAIL: Could not fetch kubeconfig from http://localhost:${port}"
    return 1
}