fix: Stabilise the CI

e2e/limavm/debian.go

@@ -4,8 +4,8 @@ type Debian struct {
 	VM
 }
 
-func NewDebian(mountDir string) (Debian, error) {
-	vm, err := newVM("debian", mountDir)
+func NewDebian() (Debian, error) {
+	vm, err := newVM("debian")
 	if err != nil {
 		return Debian{}, err
 	}

e2e/limavm/docker.go

@@ -8,8 +8,8 @@ type Docker struct {
 	VM
 }
 
-func NewDocker(mountDir string) (Docker, error) {
-	vm, err := newVM("docker", mountDir)
+func NewDocker() (Docker, error) {
+	vm, err := newVM("docker")
 	if err != nil {
 		return Docker{}, err
 	}

e2e/limavm/limavm.go

@@ -19,11 +19,15 @@ var BinBuildEnv = map[string]string{
 	"GOOS": "linux",
 }
 
-func newVM(template string, mountDir string) (VM, error) {
-	vmName, err := scripts.PrepareLimaVM(template, mountDir)
+func newVM(template string) (VM, error) {
+	vmName, err := scripts.PrepareLimaVM(template)
 	return VM{name: vmName}, err
 }
 
+func (vm VM) Name() string {
+	return vm.name
+}
+
 func (vm VM) InstallBin(binToInstall string) (InstalledBin, error) {
 	installPath, err := scripts.InstallBin(vm.name, binToInstall)
 	if err != nil {
@@ -84,6 +88,14 @@ func (vm VM) RunCommand(name string, args ...string) (stdout, stderr string, err
 	return stdout, stderr, nil
 }
 
+func (vm VM) ReadFile(path string) (string, error) {
+	stdout, stderr, err := vm.RunCommand("cat", path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read file %s: %w\nstderr:\n%s", path, err, stderr)
+	}
+	return stdout, nil
+}
+
 type Runnable interface {
 	Run(args ...string) (stdout, stderr string, err error)
 }
@@ -97,6 +109,10 @@ func (b InstalledBin) Run(args ...string) (stdout, stderr string, err error) {
 	return b.vm.RunCommand(b.pathToBin, args...)
 }
 
+func (b InstalledBin) Command(args ...string) *exec.Cmd {
+	return b.vm.cmd(b.pathToBin, args...)
+}
+
 func (b InstalledBin) Path() string {
 	return b.pathToBin
 }

e2e/limavm/podman.go

@@ -8,8 +8,8 @@ type Podman struct {
 	VM
 }
 
-func NewPodman(mountDir string) (Podman, error) {
-	vm, err := newVM("podman", mountDir)
+func NewPodman() (Podman, error) {
+	vm, err := newVM("podman")
 	if err != nil {
 		return Podman{}, err
 	}

e2e/limavm/scripts/prepare-lima-vm.sh

@@ -10,7 +10,6 @@ MOUNT_DIR=""
 usage() {
     echo "Usage: $0 <template> <mount-dir>" >&2
     echo "  template:         Lima template to use (docker or podman)" >&2
-    echo "  mount-dir:        Directory attached in the vm" >&2
     exit 1
 }
 
@@ -22,7 +21,7 @@ cleanup_on_failure() {
 
 create_vm() {
     echo "Creating Lima VM..." >&2
-    if ! limactl create --tty=false --name "$VM_NAME" --set ".mounts += [{\"location\":\"$MOUNT_DIR\",\"writable\":true}]" "template://$TEMPLATE"; then
+    if ! limactl create --tty=false --name "$VM_NAME" "template://$TEMPLATE"; then
         echo "Error: Failed to create VM" >&2
         exit 1
     fi
@@ -38,12 +37,11 @@ start_vm() {
 }
 
 main() {
-    if [ $# -ne 2 ]; then
+    if [ $# -ne 1 ]; then
         usage
     fi
 
     TEMPLATE="$1"
-    MOUNT_DIR="$2"
 
     VM_NAME="remoteproc-test-vm-$(date +%s)"
     echo "Creating VM: $VM_NAME" >&2

e2e/limavm/scripts/scripts.go

@@ -18,11 +18,11 @@ var (
 	teardownLimaVMScript = filepath.Join(scriptsDir, "teardown-lima-vm.sh")
 )
 
-func PrepareLimaVM(template string, mountDir string) (string, error) {
-	prepareCmd := exec.Command(prepareLimaVMScript, template, mountDir)
+func PrepareLimaVM(template string) (string, error) {
+	prepareCmd := exec.Command(prepareLimaVMScript, template)
 	prepareStreamer := runner.NewStreamingCmd(prepareCmd).WithPrefix("prepare-vm")
 
-	if err := prepareStreamer.Start(); err != nil {
+	if err := prepareStreamer.Start(nil); err != nil {
 		return "", fmt.Errorf("failed to start prepare-lima script: %w", err)
 	}
 
@@ -42,7 +42,7 @@ func InstallBin(vmName string, binToInstall string) (string, error) {
 	installCmd := exec.Command(installBinScript, vmName, binToInstall)
 	installStreamer := runner.NewStreamingCmd(installCmd).WithPrefix("install-bin")
 
-	if err := installStreamer.Start(); err != nil {
+	if err := installStreamer.Start(nil); err != nil {
 		return "", fmt.Errorf("failed to start install-bin script: %w", err)
 	}
 
@@ -67,7 +67,7 @@ func BuildImage(vmName string, template string, buildContext string, imageName s
 	buildCmd := exec.Command(buildImageScript, vmName, template, buildContext, imageName)
 	buildStreamer := runner.NewStreamingCmd(buildCmd).WithPrefix("build-image")
 
-	if err := buildStreamer.Start(); err != nil {
+	if err := buildStreamer.Start(nil); err != nil {
 		return fmt.Errorf("failed to start build-image script: %w", err)
 	}
 

e2e/remoteproc/assert.go

@@ -1,37 +1,37 @@
 package remoteproc
 
 import (
-	"os"
 	"path/filepath"
 	"testing"
 	"time"
 
+	"github.com/arm/remoteproc-runtime/e2e/limavm"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func AssertState(t testing.TB, deviceDir string, wantState string) {
+func AssertState(t testing.TB, deviceDir string, vm limavm.VM, wantState string) {
 	t.Helper()
 	const waitFor = 500 * time.Millisecond
 	const tickEvery = 100 * time.Millisecond
 	stateFilePath := filepath.Join(deviceDir, "state")
 	assert.EventuallyWithT(t, func(c *assert.CollectT) {
-		assertFileContent(c, stateFilePath, wantState)
+		assertFileContent(c, stateFilePath, vm, wantState)
 	}, waitFor, tickEvery)
 }
 
-func RequireState(t testing.TB, deviceDir string, wantState string) {
+func RequireState(t testing.TB, deviceDir string, vm limavm.VM, wantState string) {
 	t.Helper()
 	const waitFor = 500 * time.Millisecond
 	const tickEvery = 100 * time.Millisecond
 	stateFilePath := filepath.Join(deviceDir, "state")
 	require.EventuallyWithT(t, func(c *assert.CollectT) {
-		assertFileContent(c, stateFilePath, wantState)
+		assertFileContent(c, stateFilePath, vm, wantState)
 	}, waitFor, tickEvery)
 }
 
-func assertFileContent(t assert.TestingT, path string, wantContent string) {
-	gotContent, err := os.ReadFile(path)
+func assertFileContent(t assert.TestingT, path string, vm limavm.VM, wantContent string) {
+	gotContent, err := vm.ReadFile(path)
 	if assert.NoError(t, err) {
 		assert.Equal(t, wantContent, string(gotContent))
 	}

e2e/remoteproc/simulator.go

@@ -1,25 +1,31 @@
 package remoteproc
 
 import (
+	"bufio"
 	"fmt"
-	"os/exec"
+	"io"
 	"path/filepath"
+	"strings"
+	"time"
 
+	"github.com/arm/remoteproc-runtime/e2e/limavm"
 	"github.com/arm/remoteproc-runtime/e2e/runner"
 )
 
 type Simulator struct {
-	cmd     *runner.StreamingCmd
-	name    string
-	index   uint
-	rootDir string
+	installedVM limavm.InstalledBin
+	cmd         *runner.StreamingCmd
+	name        string
+	index       uint
+	rootDir     string
 }
 
-func NewSimulator(rootDir string) *Simulator {
+func NewSimulator(installedVM limavm.InstalledBin, rootDir string) *Simulator {
 	return &Simulator{
-		rootDir: rootDir,
-		index:   0,
-		name:    "some-cpu",
+		installedVM: installedVM,
+		rootDir:     rootDir,
+		index:       0,
+		name:        "some-cpu",
 	}
 }
 
@@ -28,21 +34,51 @@ func (r *Simulator) WithName(name string) *Simulator {
 	return r
 }
 
+func (r *Simulator) WithIndex(index uint) *Simulator {
+	r.index = index
+	return r
+}
+
 func (r *Simulator) Start() error {
-	cmd := exec.Command(
-		"remoteproc-simulator",
+	cmd := r.installedVM.Command(
 		"--root-dir", r.rootDir,
 		"--index", fmt.Sprintf("%d", r.index),
 		"--name", r.name,
 	)
-	streamer := runner.NewStreamingCmd(cmd).WithPrefix("remoteproc-simulator")
-	if err := streamer.Start(); err != nil {
+	streamer := runner.NewStreamingCmd(cmd).WithPrefix("simulator: " + r.name + ": ")
+	reader, writer := io.Pipe()
+	if err := streamer.Start(writer); err != nil {
 		return fmt.Errorf("failed to start simulator: %w", err)
 	}
 	r.cmd = streamer
+
+	if err := r.waitForBoot(15*time.Second, reader); err != nil {
+		_ = r.Stop()
+		return fmt.Errorf("simulator failed to create remoteproc device: %w", err)
+	}
+
 	return nil
 }
 
+func (r *Simulator) waitForBoot(waitingTime time.Duration, outputBuf *io.PipeReader) error {
+	deadline := time.Now().Add(waitingTime)
+	scanner := bufio.NewScanner(outputBuf)
+	for scanner.Scan() {
+		if time.Now().After(deadline) {
+			return fmt.Errorf("timeout waiting for simulator to create remoteproc device")
+		}
+		line := scanner.Text()
+		if strings.Contains(line, "Remoteproc initialized at") {
+			err := outputBuf.Close()
+			if err != nil {
+				return fmt.Errorf("failed to close output buffer: %w", err)
+			}
+			return nil
+		}
+	}
+	panic("unreachable")
+}
+
 func (r *Simulator) Stop() error {
 	if r.cmd != nil {
 		return r.cmd.Stop()

e2e/repo/bin.go

@@ -1,10 +1,12 @@
 package repo
 
 import (
+	"bufio"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 )
 
 func BuildRuntimeBin(binOutDir string, rootPathPrefix string, env map[string]string) (string, error) {
@@ -72,3 +74,92 @@ func BuildBothBins(binOutDir string, rootPathPrefix string, env map[string]strin
 
 	return []string{runtime, shim}, nil
 }
+
+func BuildRemoteprocSimulator(binOutDir string, env map[string]string) (string, error) {
+	const repoURL = "https://github.com/arm/remoteproc-simulator.git"
+	const repoDirName = "remoteproc-simulator"
+	binOut := filepath.Join(binOutDir, "remoteproc-simulator")
+
+	tempDir, err := os.MkdirTemp("", "remoteproc-simulator-*")
+	if err != nil {
+		return "", fmt.Errorf("failed to create temp directory: %w", err)
+	}
+	defer func() { _ = os.RemoveAll(tempDir) }()
+
+	repoDir := filepath.Join(tempDir, repoDirName)
+
+	clone := exec.Command("git", "clone", "--quiet", repoURL, repoDir)
+	clone.Env = os.Environ()
+	for k, v := range env {
+		clone.Env = append(clone.Env, fmt.Sprintf("%s=%s", k, v))
+	}
+	if out, err := clone.CombinedOutput(); err != nil {
+		return "", fmt.Errorf("failed to clone remoteproc simulator repository: %w\n%s", err, out)
+	}
+
+	tagCmd := exec.Command("git", "tag", "--list", "--sort=-version:refname")
+	tagCmd.Dir = repoDir
+	tagCmd.Env = os.Environ()
+	for k, v := range env {
+		tagCmd.Env = append(tagCmd.Env, fmt.Sprintf("%s=%s", k, v))
+	}
+
+	tagOutput, err := tagCmd.StdoutPipe()
+	if err != nil {
+		return "", fmt.Errorf("failed to create stdout pipe for tag listing: %w", err)
+	}
+
+	if err := tagCmd.Start(); err != nil {
+		return "", fmt.Errorf("failed to list tags for remoteproc simulator: %w", err)
+	}
+
+	var latestTag string
+	scanner := bufio.NewScanner(tagOutput)
+	for scanner.Scan() {
+		tag := strings.TrimSpace(scanner.Text())
+		if tag == "" {
+			continue
+		}
+		if !strings.HasPrefix(tag, "v") {
+			continue
+		}
+		latestTag = tag
+		break
+	}
+	if err := scanner.Err(); err != nil {
+		return "", fmt.Errorf("failed to read tags for remoteproc simulator: %w", err)
+	}
+	if err := tagCmd.Wait(); err != nil {
+		return "", fmt.Errorf("failed to list tags for remoteproc simulator: %w", err)
+	}
+
+	if latestTag == "" {
+		return "", fmt.Errorf("no semantic version tag found in remoteproc simulator repository")
+	}
+
+	checkout := exec.Command("git", "checkout", "--quiet", latestTag)
+	checkout.Dir = repoDir
+	checkout.Env = os.Environ()
+	for k, v := range env {
+		checkout.Env = append(checkout.Env, fmt.Sprintf("%s=%s", k, v))
+	}
+	if out, err := checkout.CombinedOutput(); err != nil {
+		return "", fmt.Errorf("failed to checkout latest tag %s: %w\n%s", latestTag, err, out)
+	}
+
+	build := exec.Command(
+		"go", "build",
+		"-o", binOut,
+		"./cmd/remoteproc-simulator",
+	)
+	build.Dir = repoDir
+	build.Env = os.Environ()
+	for k, v := range env {
+		build.Env = append(build.Env, fmt.Sprintf("%s=%s", k, v))
+	}
+
+	if out, err := build.CombinedOutput(); err != nil {
+		return "", fmt.Errorf("failed to build remoteproc simulator: %s\n%s", err, out)
+	}
+	return binOut, nil
+}