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) ReadFileAsString(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

@@ -8,9 +8,8 @@ TEMPLATE=""
 MOUNT_DIR=""
 
 usage() {
-    echo "Usage: $0 <template> <mount-dir>" >&2
+    echo "Usage: $0 <template>" >&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,38 +1,38 @@
 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, vm limavm.VM, deviceDir, 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, vm, stateFilePath, wantState)
 	}, waitFor, tickEvery)
 }
 
-func RequireState(t testing.TB, deviceDir string, wantState string) {
+func RequireState(t testing.TB, vm limavm.VM, deviceDir, 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, vm, stateFilePath, wantState)
 	}, waitFor, tickEvery)
 }
 
-func assertFileContent(t assert.TestingT, path string, wantContent string) {
-	gotContent, err := os.ReadFile(path)
+func assertFileContent(t assert.TestingT, vm limavm.VM, path, wantContent string) {
+	gotContent, err := vm.ReadFileAsString(path)
 	if assert.NoError(t, err) {
-		assert.Equal(t, wantContent, string(gotContent))
+		assert.Equal(t, wantContent, 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,72 @@ 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 {
+		stopError := r.Stop()
+		if stopError != nil {
+			return fmt.Errorf("simulator failed to create remoteproc device: %w: %s", err, stopError)
+		}
+		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)
+	timer := time.NewTimer(time.Until(deadline))
+	defer timer.Stop()
+	scanCh := make(chan string)
+	errCh := make(chan error)
+
+	go func() {
+		for scanner.Scan() {
+			scanCh <- scanner.Text()
+		}
+		if err := scanner.Err(); err != nil {
+			errCh <- err
+		} else {
+			close(scanCh)
+		}
+	}()
+
+	for {
+		select {
+		case <-timer.C:
+			return fmt.Errorf("timeout waiting for simulator to create remoteproc device")
+		case line, ok := <-scanCh:
+			if !ok {
+				return fmt.Errorf("simulator output closed before remoteproc device was created")
+			}
+			if strings.Contains(line, "Remoteproc initialized at") {
+				_ = outputBuf.Close()
+				return nil
+			}
+		case err := <-errCh:
+			return fmt.Errorf("scanner error: %w", err)
+		}
+	}
+}
+
 func (r *Simulator) Stop() error {
 	if r.cmd != nil {
 		return r.cmd.Stop()