Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

Install QEMU user-locally on apt hosts without sudo

injaneityf80471fbb575
diff --git a/libs/cua/crates/cua-daemon/src/local.rs b/libs/cua/crates/cua-daemon/src/local.rs
index 6895913c55..57b22bfbb8 100644
--- a/libs/cua/crates/cua-daemon/src/local.rs
+++ b/libs/cua/crates/cua-daemon/src/local.rs
@@ -1391,6 +1391,13 @@ async fn kvm_step(dry_run: bool) -> Option<cua_proto::daemon::v1::SetupStep> {
}
let denied = cua_vmm::host::kvm_usable()
.is_err_and(|e| e.kind() == std::io::ErrorKind::PermissionDenied);
+ if denied && !dry_run && !cua_vmm::host::sudo_available() {
+ return Some(SetupStep {
+ name: "kvm".into(),
+ status: CheckStatus::Ok as i32,
+ detail: "KVM access denied; using slow TCG emulation (sudo unavailable)".into(),
+ });
+ }
let user = std::env::var("USER").ok();
let run = async |program: &str, args: &[&str]| cua_vmm::host::run(program, args).await;
let (status, detail) =
diff --git a/libs/cua/crates/cua-vmm/src/auto.rs b/libs/cua/crates/cua-vmm/src/auto.rs
index 55f59db127..ad3552f408 100644
--- a/libs/cua/crates/cua-vmm/src/auto.rs
+++ b/libs/cua/crates/cua-vmm/src/auto.rs
@@ -259,6 +259,12 @@ pub async fn doctor() -> DoctorReport {
.push(format!("qemu-system-{native} / qemu-img"));
let step = match host_os {
HostOs::Macos if host::which("brew").is_some() => Some("brew install qemu".into()),
+ HostOs::Linux if host::which("apt-get").is_some() && !host::sudo_available() => {
+ Some(format!(
+ "user-local QEMU at {}",
+ host::cua_home().join("qemu").display()
+ ))
+ }
HostOs::Linux => QemuPackageManager::detect().map(|(manager, _)| manager.render()),
_ => None,
};
@@ -267,6 +273,12 @@ pub async fn doctor() -> DoctorReport {
qemu_status.provisioning.push(s);
}
}
+ if host::cua_home().join("qemu").is_dir() {
+ qemu_status.detail.push_str(&format!(
+ "; user-local wrappers at {}",
+ host::cua_home().join("bin").display()
+ ));
+ }
note_kvm(&mut qemu_status, host_os, &kvm);
// Lume.
@@ -416,14 +428,32 @@ pub async fn doctor() -> DoctorReport {
}
fn note_kvm(status: &mut BackendStatus, host_os: HostOs, kvm: &std::io::Result<()>) {
+ note_kvm_with(status, host_os, kvm, host::sudo_available);
+}
+
+fn note_kvm_with(
+ status: &mut BackendStatus,
+ host_os: HostOs,
+ kvm: &std::io::Result<()>,
+ sudo: impl Fn() -> bool,
+) {
if let Err(e) = kvm
&& host_os == HostOs::Linux
{
- if host::qemu_accel(host_os, Arch::host(), kvm).is_err() {
+ if host::qemu_accel_with(host_os, Arch::host(), kvm, sudo, |_| {}).is_err() {
status.ready = false;
status.missing.push(host::kvm_hint(e));
} else {
- status.detail = format!("{}; {}", status.detail, host::kvm_hint(e));
+ status.detail = format!(
+ "{}; {}{}",
+ status.detail,
+ if e.kind() == std::io::ErrorKind::PermissionDenied {
+ "TCG ready; "
+ } else {
+ ""
+ },
+ host::kvm_hint(e)
+ );
}
}
}
@@ -696,27 +726,30 @@ mod tests {
#[test]
fn doctor_reports_why_native_qemu_has_no_kvm() {
- let noted = |kvm: std::io::Result<()>| {
+ let noted = |kvm: std::io::Result<()>, sudo| {
let mut q = report(true, false, false, false, HostOs::Linux).backends[1].clone();
q.detail = "QEMU 10".into();
q.missing.clear();
- note_kvm(&mut q, HostOs::Linux, &kvm);
+ note_kvm_with(&mut q, HostOs::Linux, &kvm, || sudo);
q
};
- let missing = noted(Err(std::io::ErrorKind::NotFound.into()));
+ let missing = noted(Err(std::io::ErrorKind::NotFound.into()), true);
assert!(missing.ready && missing.missing.is_empty(), "{missing:?}");
assert!(missing.detail.starts_with("QEMU 10; "), "{missing:?}");
assert!(
missing.detail.contains("nested virtualization"),
"{missing:?}"
);
- let denied = noted(Err(std::io::ErrorKind::PermissionDenied.into()));
+ let denied = noted(Err(std::io::ErrorKind::PermissionDenied.into()), true);
assert!(!denied.ready && !denied.provisionable, "{denied:?}");
assert!(
denied.missing[0].contains("sudo usermod -aG kvm"),
"{denied:?}"
);
- let ok = noted(Ok(()));
+ let denied = noted(Err(std::io::ErrorKind::PermissionDenied.into()), false);
+ assert!(denied.ready && denied.missing.is_empty(), "{denied:?}");
+ assert!(denied.detail.contains("TCG ready"), "{denied:?}");
+ let ok = noted(Ok(()), true);
assert!(
ok.ready && ok.missing.is_empty() && ok.detail == "QEMU 10",
"{ok:?}"
diff --git a/libs/cua/crates/cua-vmm/src/host.rs b/libs/cua/crates/cua-vmm/src/host.rs
index f7747efe8d..7e7400d80a 100644
--- a/libs/cua/crates/cua-vmm/src/host.rs
+++ b/libs/cua/crates/cua-vmm/src/host.rs
@@ -163,16 +163,48 @@ pub async fn run(program: impl AsRef<std::ffi::OsStr>, args: &[&str]) -> Result<
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
}
+static SUDO_AVAILABLE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+
+pub fn sudo_available() -> bool {
+ *SUDO_AVAILABLE.get_or_init(|| {
+ which("sudo").is_some_and(|sudo| {
+ std::process::Command::new(sudo)
+ .args(["-n", "true"])
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .is_ok_and(|s| s.success())
+ })
+ })
+}
+
/// Whether hardware virtualisation is usable for a guest of `guest` arch, and
/// which QEMU accelerator to use.
pub fn qemu_accel(os: HostOs, guest: Arch, kvm: &std::io::Result<()>) -> Result<&'static str> {
+ qemu_accel_with(os, guest, kvm, sudo_available, |message| {
+ tracing::warn!("{message}")
+ })
+}
+
+pub(crate) fn qemu_accel_with(
+ os: HostOs,
+ guest: Arch,
+ kvm: &std::io::Result<()>,
+ sudo: impl Fn() -> bool,
+ mut warn: impl FnMut(&str),
+) -> Result<&'static str> {
let host = Arch::host();
match (os, kvm) {
// HVF only virtualises the host's own architecture.
(HostOs::Macos, _) if host == guest => Ok("hvf"),
(HostOs::Linux, Ok(())) if host == guest => Ok("kvm"),
(HostOs::Linux, Err(e)) if host == guest && e.kind() != std::io::ErrorKind::NotFound => {
- Err(VmmError::missing("KVM", kvm_hint(e)))
+ if e.kind() == std::io::ErrorKind::PermissionDenied && !sudo() {
+ warn("KVM access denied and sudo unavailable; using slow TCG emulation");
+ Ok("tcg")
+ } else {
+ Err(VmmError::missing("KVM", kvm_hint(e)))
+ }
}
(HostOs::Windows, _) if host == guest => Ok("whpx"),
_ => Ok("tcg"),
@@ -312,7 +344,7 @@ mod tests {
#[test]
fn native_linux_accel_tells_missing_from_unopenable_kvm() {
- let native = |kvm| qemu_accel(HostOs::Linux, Arch::host(), &kvm);
+ let native = |kvm| qemu_accel_with(HostOs::Linux, Arch::host(), &kvm, || true, |_| {});
assert_eq!(native(Ok(())).unwrap(), "kvm");
assert_eq!(
native(Err(std::io::ErrorKind::NotFound.into())).unwrap(),
@@ -320,14 +352,29 @@ mod tests {
);
let missing = kvm_hint(&std::io::ErrorKind::NotFound.into());
assert!(missing.contains("nested virtualization"), "{missing}");
- let denied = native(Err(std::io::ErrorKind::PermissionDenied.into()))
- .unwrap_err()
- .to_string();
+ let denied = native(Err(std::io::ErrorKind::PermissionDenied.into()));
+ let denied = denied.unwrap_err().to_string();
assert!(denied.contains("permission denied"), "{denied}");
assert!(
denied.contains("sudo usermod -aG kvm \"$USER\""),
"{denied}"
);
+ let mut warning = String::new();
+ assert_eq!(
+ qemu_accel_with(
+ HostOs::Linux,
+ Arch::host(),
+ &Err(std::io::ErrorKind::PermissionDenied.into()),
+ || false,
+ |message| warning.push_str(message)
+ )
+ .unwrap(),
+ "tcg"
+ );
+ assert_eq!(
+ warning,
+ "KVM access denied and sudo unavailable; using slow TCG emulation"
+ );
let other = native(Err(std::io::Error::other("device busy")))
.unwrap_err()
.to_string();
diff --git a/libs/cua/crates/cua-vmm/src/qemu/firmware.rs b/libs/cua/crates/cua-vmm/src/qemu/firmware.rs
index 886f1e90b8..b4dd5c485a 100644
--- a/libs/cua/crates/cua-vmm/src/qemu/firmware.rs
+++ b/libs/cua/crates/cua-vmm/src/qemu/firmware.rs
@@ -25,6 +25,11 @@ pub struct Uefi {
fn candidates(arch: Arch) -> &'static [(&'static str, &'static str)] {
match arch {
Arch::Aarch64 => &[
+ (
+ "qemu/usr/share/AAVMF/AAVMF_CODE.fd",
+ "qemu/usr/share/AAVMF/AAVMF_VARS.fd",
+ ),
+ ("qemu/usr/share/qemu-efi-aarch64/QEMU_EFI.fd", ""),
(
"share/qemu/edk2-aarch64-code.fd",
"share/qemu/edk2-arm-vars.fd",
@@ -44,6 +49,10 @@ fn candidates(arch: Arch) -> &'static [(&'static str, &'static str)] {
("/usr/share/qemu-efi-aarch64/QEMU_EFI.fd", ""),
],
Arch::X86_64 => &[
+ (
+ "qemu/usr/share/OVMF/OVMF_CODE_4M.fd",
+ "qemu/usr/share/OVMF/OVMF_VARS_4M.fd",
+ ),
(
"share/qemu/edk2-x86_64-code.fd",
"share/qemu/edk2-i386-vars.fd",
@@ -131,6 +140,34 @@ mod tests {
use super::*;
use std::collections::HashSet;
+ #[test]
+ fn local_wrapper_firmware() {
+ let code = "/local/qemu/usr/share/qemu-efi-aarch64/QEMU_EFI.fd";
+ let found = find_uefi_with(
+ Arch::Aarch64,
+ Path::new("/local/bin/qemu-system-aarch64"),
+ fs(&[code]),
+ )
+ .unwrap();
+ assert_eq!(found.code, Path::new(code));
+ assert!(found.vars_template.is_none());
+ for (arch, code, vars) in [
+ (Arch::X86_64, "OVMF/OVMF_CODE_4M.fd", "OVMF/OVMF_VARS_4M.fd"),
+ (Arch::Aarch64, "AAVMF/AAVMF_CODE.fd", "AAVMF/AAVMF_VARS.fd"),
+ ] {
+ let code = format!("/local/qemu/usr/share/{code}");
+ let vars = format!("/local/qemu/usr/share/{vars}");
+ let found = find_uefi_with(
+ arch,
+ Path::new("/local/bin/qemu-system-test"),
+ fs(&[&code, &vars]),
+ )
+ .unwrap();
+ assert_eq!(found.code, Path::new(&code));
+ assert_eq!(found.vars_template.as_deref(), Some(Path::new(&vars)));
+ }
+ }
+
fn fs(paths: &[&str]) -> impl Fn(&Path) -> bool {
let set: HashSet<PathBuf> = paths.iter().map(PathBuf::from).collect();
move |p: &Path| set.contains(p)
diff --git a/libs/cua/crates/cua-vmm/src/qemu/install-local.sh b/libs/cua/crates/cua-vmm/src/qemu/install-local.sh
new file mode 100644
index 0000000000..3d75400089
--- /dev/null
+++ b/libs/cua/crates/cua-vmm/src/qemu/install-local.sh
@@ -0,0 +1,54 @@
+#!/bin/sh
+set -eu
+home=$1
+case $(uname -m) in
+ x86_64) system=qemu-system-x86_64; packages='qemu-system-x86 seabios ipxe-qemu ovmf' ;;
+ aarch64|arm64) system=qemu-system-aarch64; packages='qemu-system-arm qemu-efi-aarch64' ;;
+ *) echo 'unsupported QEMU host architecture' >&2; exit 1 ;;
+esac
+mkdir -p "$home/bin"
+stage=$(mktemp -d "$home/.qemu-XXXXXXXX")
+old=$stage/old
+trap 'rm -rf "$stage"' EXIT
+trap 'exit 1' HUP INT TERM
+mkdir -p "$stage/lists/partial" "$stage/cache/archives/partial" "$stage/root"
+set -- -o "Dir::State::Lists=$stage/lists" -o "Dir::Cache=$stage/cache" -o Debug::NoLocking=1
+apt-get "$@" update
+apt-get "$@" --download-only --reinstall --no-install-recommends -y install $packages qemu-system-common qemu-system-data qemu-utils
+for deb in "$stage/cache/archives/"*.deb; do dpkg-deb -x "$deb" "$stage/root"; done
+find "$stage/root" -type l -exec sh -c '
+ root=$1; shift
+ for link do
+ target=$(readlink "$link")
+ case $target in /*)
+ if [ -e "$root$target" ]; then
+ relative=$(realpath -s --relative-to="$(dirname "$link")" "$root$target")
+ ln -snf "$relative" "$link"
+ fi ;;
+ esac
+ done
+' sh "$stage/root" {} +
+wrapper() {
+ root=$1; binary=$2; destination=$3
+ quoted=$(printf '%s' "$root" | sed "s/'/'\\\\''/g")
+ {
+ printf "#!/bin/sh\nroot='%s'\n" "$quoted"
+ printf '%s\n' 'export LD_LIBRARY_PATH="$root/usr/lib:$(find "$root/usr/lib" -mindepth 1 -maxdepth 1 -type d | paste -sd: -)${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"' 'export QEMU_MODULE_DIR="$(find "$root/usr/lib" -mindepth 2 -maxdepth 2 -type d -path "*-linux-gnu*/qemu" | head -n 1)"'
+ if [ "$binary" = qemu-img ]; then
+ printf 'exec "$root/usr/bin/%s" "$@"\n' "$binary"
+ else
+ printf 'exec "$root/usr/bin/%s" -L "$root/usr/share/qemu" "$@"\n' "$binary"
+ fi
+ } > "$destination"
+ chmod +x "$destination"
+}
+for binary in "$system" qemu-img; do
+ wrapper "$stage/root" "$binary" "$stage/$binary"
+ "$stage/$binary" --version
+done
+[ ! -e "$home/qemu" ] || mv "$home/qemu" "$old"
+mv "$stage/root" "$home/qemu"
+for binary in "$system" qemu-img; do
+ wrapper "$home/qemu" "$binary" "$stage/$binary"
+ mv "$stage/$binary" "$home/bin/$binary"
+done
diff --git a/libs/cua/crates/cua-vmm/src/qemu/mod.rs b/libs/cua/crates/cua-vmm/src/qemu/mod.rs
index dd5a8a7360..c85e69913c 100644
--- a/libs/cua/crates/cua-vmm/src/qemu/mod.rs
+++ b/libs/cua/crates/cua-vmm/src/qemu/mod.rs
@@ -298,10 +298,21 @@ impl QemuRuntime {
}
fn accel_for(&self, arch: Arch, kvm: &std::io::Result<()>) -> Result<String> {
+ self.accel_for_with(arch, kvm, host::sudo_available)
+ }
+
+ fn accel_for_with(
+ &self,
+ arch: Arch,
+ kvm: &std::io::Result<()>,
+ sudo: impl Fn() -> bool,
+ ) -> Result<String> {
if let Some(accel) = &self.cfg.accel {
return Ok(accel.clone());
}
- let accel = host::qemu_accel(host::HostOs::current(), arch, kvm)?;
+ let accel = host::qemu_accel_with(host::HostOs::current(), arch, kvm, sudo, |message| {
+ tracing::warn!("{message}")
+ })?;
if let Err(e) = kvm
&& accel == "tcg"
&& arch == Arch::host()
@@ -1023,6 +1034,19 @@ pub async fn grant_kvm(
const PACKAGE_ATTEMPTS: u32 = 3;
pub async fn install_qemu() -> Result<()> {
+ install_qemu_with(
+ QemuPackageManager::detect(),
+ host::sudo_available,
+ async |p, a| host::run(p, a).await,
+ )
+ .await
+}
+
+async fn install_qemu_with(
+ manager: Option<(QemuPackageManager, PathBuf)>,
+ sudo: impl Fn() -> bool,
+ run: impl AsyncFn(&str, &[&str]) -> Result<String>,
+) -> Result<()> {
match host::HostOs::current() {
host::HostOs::Macos => {
let brew = host::which("brew").ok_or_else(|| {
@@ -1032,19 +1056,37 @@ pub async fn install_qemu() -> Result<()> {
)
})?;
tracing::info!("installing QEMU with Homebrew");
- host::run(brew, &["install", "qemu"]).await?;
+ run(&brew.to_string_lossy(), &["install", "qemu"]).await?;
}
host::HostOs::Linux => {
- let (manager, program) = QemuPackageManager::detect().ok_or_else(|| {
+ let (manager, program) = manager.ok_or_else(|| {
VmmError::missing("QEMU", "no supported package manager found (apt-get/dnf)")
})?;
+ if matches!(manager, QemuPackageManager::Apt) && !sudo() {
+ let home = host::cua_home();
+ tracing::info!(
+ "installing user-local QEMU at {}",
+ home.join("qemu").display()
+ );
+ return run(
+ "sh",
+ &[
+ "-c",
+ include_str!("install-local.sh"),
+ "cua-qemu",
+ &home.to_string_lossy(),
+ ],
+ )
+ .await
+ .map(|_| ());
+ }
let program = program.display().to_string();
tracing::info!("installing QEMU with {manager:?} (sudo -n)");
for args in manager.commands(&program) {
let refresh = args.last() == Some(&"update");
let mut attempt = 1;
loop {
- match host::run("sudo", &args).await {
+ match run("sudo", &args).await {
Ok(_) => break,
Err(e) if attempt < PACKAGE_ATTEMPTS => {
tracing::warn!(
@@ -1601,15 +1643,94 @@ mod tests {
assert!(err.to_string().contains("DiskResolver"));
}
+ #[cfg(target_os = "linux")]
+ #[tokio::test]
+ async fn install_without_sudo_runs_local_script() {
+ let calls = std::sync::Mutex::new(Vec::new());
+ install_qemu_with(
+ Some((QemuPackageManager::Apt, PathBuf::from("apt-get"))),
+ || false,
+ async |program, args| {
+ calls.lock().unwrap().push((
+ program.to_string(),
+ args.iter().map(|a| a.to_string()).collect::<Vec<_>>(),
+ ));
+ Ok(String::new())
+ },
+ )
+ .await
+ .unwrap();
+ let calls = calls.lock().unwrap();
+ assert_eq!(calls.len(), 1);
+ assert_eq!(calls[0].0, "sh");
+ assert_eq!(calls[0].1[1], include_str!("install-local.sh"));
+ assert_eq!(calls[0].1[3], host::cua_home().to_string_lossy());
+ assert!(calls.iter().all(|(program, _)| program != "sudo"));
+ }
+
+ #[cfg(target_os = "linux")]
+ #[tokio::test]
+ async fn install_with_sudo_preserves_package_commands() {
+ let calls = std::sync::Mutex::new(Vec::new());
+ install_qemu_with(
+ Some((QemuPackageManager::Apt, PathBuf::from("apt-get"))),
+ || true,
+ async |program, args| {
+ assert_eq!(program, "sudo");
+ calls
+ .lock()
+ .unwrap()
+ .push(args.iter().map(|a| a.to_string()).collect::<Vec<_>>());
+ Ok(String::new())
+ },
+ )
+ .await
+ .unwrap();
+ let expected: Vec<Vec<String>> = QemuPackageManager::Apt
+ .commands("apt-get")
+ .iter()
+ .map(|args| args.iter().map(|a| a.to_string()).collect())
+ .collect();
+ assert_eq!(*calls.lock().unwrap(), expected);
+ }
+
+ #[cfg(target_os = "linux")]
+ #[test]
+ fn local_installer_fixtures() {
+ let python = std::process::Command::new("python3")
+ .arg("--version")
+ .output();
+ if python.is_err_and(|e| e.kind() == std::io::ErrorKind::NotFound) {
+ return;
+ }
+ assert!(
+ std::process::Command::new("python3")
+ .arg(concat!(
+ env!("CARGO_MANIFEST_DIR"),
+ "/tests/install_local.py"
+ ))
+ .status()
+ .unwrap()
+ .success()
+ );
+ }
+
#[cfg(target_os = "linux")]
#[test]
fn native_launch_refuses_unopenable_kvm_and_falls_back_when_missing() {
let tmp = tempfile::tempdir().unwrap();
let r = rt(tmp.path());
let denied = Err(std::io::ErrorKind::PermissionDenied.into());
- let err = r.accel_for(Arch::host(), &denied).unwrap_err().to_string();
- assert!(err.contains("permission denied"), "{err}");
- assert!(err.contains("sudo usermod -aG kvm"), "{err}");
+ let error = r
+ .accel_for_with(Arch::host(), &denied, || true)
+ .unwrap_err()
+ .to_string();
+ assert!(error.contains("permission denied"), "{error}");
+ assert!(error.contains("sudo usermod -aG kvm \"$USER\""), "{error}");
+ assert_eq!(
+ r.accel_for_with(Arch::host(), &denied, || false).unwrap(),
+ "tcg"
+ );
let missing = Err(std::io::ErrorKind::NotFound.into());
assert_eq!(r.accel_for(Arch::host(), &missing).unwrap(), "tcg");
}
diff --git a/libs/cua/crates/cua-vmm/tests/install_local.py b/libs/cua/crates/cua-vmm/tests/install_local.py
new file mode 100644
index 0000000000..6281db7342
--- /dev/null
+++ b/libs/cua/crates/cua-vmm/tests/install_local.py
@@ -0,0 +1,65 @@
+"""Hermetic installer regression: no apt network, sudo, or VM execution."""
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+import unittest
+
+SCRIPT = Path(__file__).parents[1] / 'src/qemu/install-local.sh'
+
+class LocalInstall(unittest.TestCase):
+ def test_install_and_failed_reinstall(self):
+ with tempfile.TemporaryDirectory() as directory:
+ base = Path(directory)
+ home = base / "home with 'quote"
+ tools = base / 'tools'
+ tools.mkdir()
+ def tool(name, body):
+ path = tools / name
+ path.write_text('#!/bin/sh\nset -eu\n' + body)
+ path.chmod(0o755)
+ tool('uname', 'echo x86_64\n')
+ tool('find', '''
+/usr/bin/find "$@" | awk '/\\/ipxe\\/qemu$/ { print; next } { rest = rest $0 "\\n" } END { printf "%s", rest }'
+''')
+ tool('apt-get', '''
+case "$*" in *--download-only*)
+ case "$*" in *--reinstall*--no-install-recommends*) ;; *) exit 20;; esac
+ for arg do case $arg in Dir::Cache=*) cache=${arg#*=};; esac; done
+ touch "$cache/archives/qemu.deb";;
+esac
+''')
+ tool('dpkg-deb', '''
+[ "${FAIL:-}" != yes ] || exit 21
+root=$3
+mkdir -p "$root/usr/bin" "$root/usr/lib/ipxe/qemu" "$root/usr/lib/qemu" "$root/usr/lib/x86_64-linux-gnu/qemu" "$root/usr/share/qemu" "$root/usr/share/seabios"
+touch "$root/usr/share/seabios/bios.bin"
+ln -s /usr/share/seabios/bios.bin "$root/usr/share/qemu/bios.bin"
+ln -s /host-only "$root/usr/share/qemu/host"
+for binary in qemu-system-x86_64 qemu-img; do
+ printf '#!/bin/sh\\nprintf "%%s\\\\n" "$QEMU_MODULE_DIR" "$LD_LIBRARY_PATH" "$@"\\n' > "$root/usr/bin/$binary"
+ chmod +x "$root/usr/bin/$binary"
+done
+''')
+ env = dict(os.environ, PATH=f'{tools}:/usr/bin:/bin')
+ subprocess.run(['sh', str(SCRIPT), str(home)], env=env, check=True, capture_output=True)
+ root = home / 'qemu'
+ link = root / 'usr/share/qemu/bios.bin'
+ self.assertFalse(os.readlink(link).startswith('/'))
+ self.assertTrue(link.exists())
+ self.assertEqual(os.readlink(root / 'usr/share/qemu/host'), '/host-only')
+ for binary in ('qemu-system-x86_64', 'qemu-img'):
+ output = subprocess.check_output([str(home / 'bin' / binary), 'a b', 'c"d'], env=env, text=True)
+ self.assertEqual(output.splitlines()[0], str(root / 'usr/lib/x86_64-linux-gnu/qemu'))
+ self.assertIn('a b\nc"d\n', output)
+ self.assertEqual('\n-L\n' in output, binary != 'qemu-img')
+ (root / 'sentinel').touch()
+ result = subprocess.run(['sh', str(SCRIPT), str(home)], env=dict(env, FAIL='yes'), capture_output=True)
+ self.assertNotEqual(result.returncode, 0)
+ self.assertTrue((root / 'sentinel').exists())
+ self.assertFalse(list(home.glob('.qemu-*')))
+ subprocess.run(['sh', str(SCRIPT), str(home)], env=env, check=True, capture_output=True)
+ self.assertFalse((root / 'sentinel').exists())
+
+if __name__ == '__main__':
+ unittest.main()