ci: build and test x16emu natively on narvi-1, OxygenHub's RISC-V runner a673804c781c

#!/bin/sh

# Build the riscv64 image the pipeline's jobs run in on narvi-1, and write it

# as a root file system tarball for `flow rootfs import`. There is no Docker

# on a RISC-V board, so this is Ubuntu Base 24.04.5 riscv64, checked against

# its published SHA-256, with the build's packages installed by apt in a

# chroot. Run it on a riscv64 Linux machine (narvi) as root or a user with

# sudo, then

#

#     FLOW_HOME=~/flow ~/flow/bin/flow rootfs import x16emu-riscv64.tar

#

# and pin the printed hash in .flow/pipeline.kdl. Rebuild, re-import and

# re-pin when the packages below change.

set -eu

here=$(cd "$(dirname "$0")" && pwd)

out=${1:-$here/x16emu-riscv64.tar}

release=24.04.5

base=ubuntu-base-$release-base-riscv64.tar.gz

sha256=651c516f291259ec913caa1efd0cfff738cd223adfc6617c884f07af487f08cf

# What the Makefile and the conformance suite need, as README.md lists for

# riscv64 Linux: C11 and C++17 compilers, make, SDL2 and zlib, Python and

# pytest.

packages="build-essential make libsdl2-dev zlib1g-dev python3 python3-pytest"

test "$(uname -m)" = riscv64 || { echo "build-riscv64.sh: run this on a riscv64 machine" >&2; exit 1; }

work=$(mktemp -d)

root=$work/root

cleanup() {

	sudo umount "$root/proc" "$root/dev" 2>/dev/null || true

	sudo rm -rf "$work"

}

trap cleanup EXIT

curl -fsSL -o "$work/$base" "https://cdimage.ubuntu.com/ubuntu-base/releases/$release/release/$base"

echo "$sha256  $work/$base" | sha256sum -c - >/dev/null

mkdir "$root"

sudo tar -C "$root" -xzf "$work/$base"

sudo mv "$root/etc/resolv.conf" "$work/resolv.conf.image" 2>/dev/null || true

sudo cp /etc/resolv.conf "$root/etc/resolv.conf"

sudo mount --bind /dev "$root/dev"

sudo mount -t proc proc "$root/proc"

sudo chroot "$root" sh -c "

	export DEBIAN_FRONTEND=noninteractive

	apt-get update -q >/dev/null

	apt-get install -y -q --no-install-recommends $packages >/dev/null

	apt-get clean

	rm -rf /var/lib/apt/lists/*"

sudo umount "$root/proc" "$root/dev"

sudo rm "$root/etc/resolv.conf"

sudo mv "$work/resolv.conf.image" "$root/etc/resolv.conf" 2>/dev/null || true

sudo tar -C "$root" -cf "$out" .

sudo chown "$(id -u):$(id -g)" "$out"

echo "$out"

# x16emu and makecart built natively on narvi-1, a riscv64 board, the way

# README.md says to build them on riscv64 Linux: plain `make`, with the

# Makefile's own -O3 -Wall -Werror, so a new warning fails the job.

set -eu

echo "building on $(uname -m), $(cc --version | head -1)"

make -j6

./x16emu -version

# The retro-remote-debug-controller conformance suite against the x16emu the

# build job made on narvi-1, as .github/workflows/conformance.yml runs it on

# x86: headless (SDL's dummy drivers), -warp, on a loopback port, with a

# zero-filled ROM, since the suite exercises the control API, not the ROM.

# pytest's JUnit XML goes to the hub's Tests tab, kept when the job fails too.

set -eu

chmod +x x16emu

truncate -s 262144 dummy-rom.bin

export RRDC_PORT=8080

export RRDC_BOOT_TIMEOUT=60

export RRDC_EMU_CMD="SDL_VIDEODRIVER=dummy SDL_AUDIODRIVER=dummy $PWD/x16emu -rom $PWD/dummy-rom.bin -warp -controlport {port}"

status=0

(cd src/extern/retro-remote-debug-controller/conformance &&

	python3 -m pytest -v -rs -p no:cacheprovider --junitxml=/src/junit.xml) || status=$?

# A suite that skipped every test never reached the emulator: that is a

# failure here, where one is always there to reach.

python3 - <<'PY'

import sys

import xml.etree.ElementTree as ET

root = ET.parse("/src/junit.xml").getroot()

suites = [root] if root.tag == "testsuite" else list(root)

tests = sum(int(s.get("tests", 0)) for s in suites)

skipped = sum(int(s.get("skipped", 0)) for s in suites)

print(f"conformance: {tests} tests, {skipped} skipped")

if tests == 0 or skipped == tests:

    sys.exit("conformance: every test skipped: the emulator did not answer on its control port")

PY

exit $status

// x16emu's pipeline on OxygenFlow: every push to a bookmark on OxygenHub

// builds the emulator natively on narvi-1, a real riscv64 board, and runs

// the control-API conformance suite against what it built. The jobs appear

// as checks on the change and in the Flow tab. The retro-remote-debug-

// controller subrepo (src/extern) is put in the workspace by the runner.

schema-version 1

// Ubuntu 24.04 riscv64 with gcc, make, SDL2, zlib, Python and pytest

// (.flow/image/build-riscv64.sh), in the syscall tier: narvi's Ky X1 has no

// hardware virtualisation, so no microVM. `runs-on` keeps it on a RISC-V

// runner. Loopback only: the suite talks to the emulator on 127.0.0.1.

sandbox "x16-riscv64" {

    runtime "syscall"

    rootfs "cas://blob/a1405289def4850dade956ea6d4e4870a73bb631cc353f16f0e5fcd796fe2541"

    runs-on "riscv64"

    memory-limit "2GiB"

    cpu-limit 6

    network "loopback"

}

// make as README.md gives it, -Werror included; the binary is kept with the

// runner's signed receipt and handed to the conformance job.

job "build" {

    sandbox "x16-riscv64"

    timeout "30m"

    exec "sh" "-eu" ".flow/jobs/build.sh"

    output {

        artifact "x16emu-linux-riscv64" {

            path "/src/x16emu"

        }

    }

}

// The conformance suite (src/extern/retro-remote-debug-controller) against

// that binary, headless; pytest's JUnit XML for the hub's Tests tab.

job "conformance" {

    sandbox "x16-riscv64"

    depends-on "build"

    timeout "15m"

    input {

        artifact "x16emu-linux-riscv64" from "build"

        path "/src/x16emu"

    }

    exec "sh" "-eu" ".flow/jobs/conformance.sh"

    output {

        artifact "junit" {

            path "/src/junit.xml"

            when "always"

        }

    }

}