WEFT_OS/crates/weft-appd/src/runtime.rs

912 lines
35 KiB
Rust

use std::path::PathBuf;
use std::time::Duration;
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader, BufWriter};
use weft_ipc_types::AppdToCompositor;
use crate::Registry;
use crate::compositor_client::CompositorSender;
use crate::ipc::{AppStateKind, Response};
use crate::launch::LaunchPackage;
use crate::mount::Mount;
/// The per-session relay between the component's IPC socket and the app
/// bridge. It belongs to the session: closing it stops the relay task and
/// removes the socket, whether or not the component ever connected.
pub(crate) struct IpcRelay {
task: tokio::task::JoinHandle<()>,
socket_path: PathBuf,
}
impl IpcRelay {
/// Completes when the relay stops: the component closed its connection
/// or the listener failed.
async fn ended(&mut self) {
let _ = (&mut self.task).await;
}
}
impl Drop for IpcRelay {
fn drop(&mut self) {
self.task.abort();
let _ = std::fs::remove_file(&self.socket_path);
}
}
/// The longest message from a component, its line break included: the
/// runtime refuses longer ones, so a longer line ends the relay.
#[cfg(unix)]
const MAX_RELAY_FRAME: usize = 64 * 1024 + 2;
/// Listens on `socket_path` for the session's component and relays
/// newline-delimited messages between it and the returned sender (towards
/// the component) and the broadcast channel (from the component).
#[cfg(unix)]
pub(crate) fn spawn_ipc_relay(
session_id: u64,
socket_path: PathBuf,
broadcast: tokio::sync::broadcast::Sender<Response>,
) -> std::io::Result<(tokio::sync::mpsc::Sender<String>, IpcRelay)> {
let _ = std::fs::remove_file(&socket_path);
let listener = tokio::net::UnixListener::bind(&socket_path)?;
{
use std::os::unix::fs::PermissionsExt;
if let Err(e) =
std::fs::set_permissions(&socket_path, std::fs::Permissions::from_mode(0o600))
{
let _ = std::fs::remove_file(&socket_path);
return Err(e);
}
}
let (html_to_wasm_tx, mut html_to_wasm_rx) = tokio::sync::mpsc::channel::<String>(64);
let task = tokio::spawn(async move {
let Ok((stream, _)) = listener.accept().await else {
tracing::warn!(session_id, "IPC relay: failed to accept connection");
return;
};
// One component per session: no further connections are accepted.
drop(listener);
tracing::debug!(session_id, "IPC relay: component connected");
// The runtime ends when its side of this connection is shut down,
// even only for writing, so the connection stays whole until the
// session ends: tokio::io::split does not shut down a dropped half,
// as UnixStream::into_split would.
let (reader, writer) = tokio::io::split(stream);
let mut reader = BufReader::new(reader);
let mut writer = BufWriter::new(writer);
// The frame being read lives outside the loop: `read_until` keeps
// what it has read when the other branch wins, so a message from the
// page never splits a message from the component.
let mut frame = Vec::new();
loop {
let mut limited = (&mut reader).take((MAX_RELAY_FRAME + 1 - frame.len()) as u64);
tokio::select! {
n = limited.read_until(b'\n', &mut frame) => {
match n {
Ok(0) | Err(_) => break,
Ok(_) if frame.len() > MAX_RELAY_FRAME => {
tracing::warn!(session_id, "IPC relay: message over the size limit");
break;
}
// The rest of the message is still to come.
Ok(_) if !frame.ends_with(b"\n") => {}
Ok(_) => {
let line = std::mem::take(&mut frame);
let Ok(text) = String::from_utf8(line) else {
tracing::warn!(session_id, "IPC relay: message is not UTF-8");
break;
};
let payload = text.trim_end_matches(['\n', '\r']).to_owned();
let _ = broadcast.send(Response::IpcMessage { session_id, payload });
}
}
}
msg = html_to_wasm_rx.recv() => {
match msg {
Some(payload) => {
let mut data = payload;
data.push('\n');
if writer.write_all(data.as_bytes()).await.is_err()
|| writer.flush().await.is_err()
{
break;
}
}
None => break,
}
}
}
}
});
Ok((html_to_wasm_tx, IpcRelay { task, socket_path }))
}
#[cfg(not(unix))]
pub(crate) fn spawn_ipc_relay(
_session_id: u64,
_socket_path: PathBuf,
_broadcast: tokio::sync::broadcast::Sender<Response>,
) -> std::io::Result<(tokio::sync::mpsc::Sender<String>, IpcRelay)> {
Err(std::io::ErrorKind::Unsupported.into())
}
const READY_TIMEOUT: Duration = Duration::from_secs(30);
/// Environment variable carrying a session's readiness token to its children.
///
/// A child reports readiness by printing `READY <token>` on its own stdout.
/// Application code shares that stdout (Wasm guests through inherited stdio,
/// pages through `window.alert`) but cannot read the token, because the
/// runtime passes the guest only the variables it names and pages cannot read
/// the host process environment.
const READY_TOKEN_ENV: &str = "WEFT_READY_TOKEN";
/// The application's close policy, `immediate` or `ask`, for the app shell.
const CLOSE_POLICY_ENV: &str = "WEFT_APP_CLOSE";
/// Environment variable carrying the session's application bridge credential
/// to weft-app-shell.
const BRIDGE_TOKEN_ENV: &str = "WEFT_BRIDGE_TOKEN";
/// Longest line read from a child's output; longer lines are split.
const MAX_LINE: u64 = 64 * 1024;
/// A random 128-bit credential as 32 hex characters.
pub(crate) fn random_token() -> std::io::Result<String> {
use std::io::Read;
let mut bytes = [0u8; 16];
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
Ok(bytes.iter().map(|b| format!("{b:02x}")).collect())
}
/// Reads one line of at most MAX_LINE bytes, decoded lossily. Returns None at
/// end of output.
async fn read_child_line<R: tokio::io::AsyncBufRead + Unpin>(
reader: &mut R,
) -> std::io::Result<Option<String>> {
use tokio::io::AsyncReadExt;
let mut line = Vec::new();
let n = (&mut *reader)
.take(MAX_LINE)
.read_until(b'\n', &mut line)
.await?;
if n == 0 {
return Ok(None);
}
Ok(Some(String::from_utf8_lossy(&line).trim_end().to_owned()))
}
/// `systemd-run` options that place the runtime in a transient user scope.
///
/// A scope runs the command in the foreground as systemd-run's own process,
/// so its stdout and exit status reach appd directly. `--wait` only applies
/// to service units; systemd rejects it together with `--scope`.
const SYSTEMD_SCOPE_ARGS: &[&str] = &[
"--user",
"--scope",
"--collect",
"--slice=weft-apps.slice",
"-p",
"CPUQuota=200%",
"-p",
"MemoryMax=512M",
"-p",
"TasksMax=512",
];
fn systemd_cgroup_available() -> bool {
if std::env::var("WEFT_DISABLE_CGROUP").is_ok() {
return false;
}
let Ok(runtime_dir) = std::env::var("XDG_RUNTIME_DIR") else {
return false;
};
std::path::Path::new(&runtime_dir)
.join("systemd/private")
.exists()
}
async fn kill_portal(portal: Option<(PathBuf, tokio::process::Child)>) {
if let Some((sock, mut child)) = portal {
let _ = child.kill().await;
let _ = child.wait().await;
let _ = std::fs::remove_file(&sock);
}
}
fn spawn_app_shell(
bin: &str,
session_id: u64,
package: &LaunchPackage,
token: &str,
bridge_token: Option<String>,
wayland: Option<std::os::unix::net::UnixStream>,
) -> std::io::Result<tokio::process::Child> {
let mut command = tokio::process::Command::new(bin);
match wayland {
// The app shell's only Wayland connection is the one created for its
// session, handed over as its standard input: WAYLAND_SOCKET names
// that descriptor, and no display socket is offered to connect
// anywhere else. Only this child receives the descriptor.
Some(stream) => {
command
.stdin(std::process::Stdio::from(std::os::fd::OwnedFd::from(
stream,
)))
.env("WAYLAND_SOCKET", "0")
.env_remove("WAYLAND_DISPLAY");
}
None => {
command.stdin(std::process::Stdio::null());
}
}
if let Some(bridge_token) = bridge_token {
// The page holds this credential; it must differ from the readiness
// token, which page output could otherwise use to fake readiness.
command.env(BRIDGE_TOKEN_ENV, bridge_token);
}
let child = command
.arg(&package.app_id)
.arg(session_id.to_string())
.arg("--ui")
.arg(&package.ui_entry)
.env(READY_TOKEN_ENV, token)
.env(CLOSE_POLICY_ENV, package.close.as_str())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.kill_on_drop(true)
.spawn()?;
tracing::info!(session_id, app_id = %package.app_id, bin, "app shell spawned");
Ok(child)
}
fn portal_socket_path(session_id: u64) -> Option<PathBuf> {
let runtime_dir = std::env::var("XDG_RUNTIME_DIR").ok()?;
let dir = PathBuf::from(runtime_dir).join("weft");
crate::private_dir(&dir).ok()?;
Some(dir.join(format!("portal-{session_id}.sock")))
}
fn spawn_file_portal(
session_id: u64,
dirs: &[crate::grants::GrantedDir],
) -> Option<(PathBuf, tokio::process::Child)> {
let bin = std::env::var("WEFT_FILE_PORTAL_BIN").ok()?;
let socket = portal_socket_path(session_id)?;
let mut cmd = tokio::process::Command::new(&bin);
cmd.arg(&socket)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null());
for dir in dirs {
let flag = match dir.access {
weft_ipc_types::capability::Access::Read => "--allow-read",
weft_ipc_types::capability::Access::ReadWrite => "--allow",
};
cmd.arg(flag).arg(&dir.host);
}
let child = cmd.kill_on_drop(true).spawn().ok()?;
tracing::info!(session_id, socket = %socket.display(), "file portal spawned");
Some((socket, child))
}
/// A request to end a session, from `TERMINATE_APP`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Stop {
/// Close as a user close would; the application may decline.
Close,
/// Terminate without asking.
Force,
}
/// Repeated requests carry nothing new, so a few queued ones are enough.
pub(crate) const STOP_QUEUE: usize = 2;
pub(crate) type StopSender = tokio::sync::mpsc::Sender<Stop>;
/// Ends when appd shuts down and drops the sender.
pub(crate) type StopReceiver = tokio::sync::mpsc::Receiver<Stop>;
pub(crate) async fn supervise(
session_id: u64,
mut package: LaunchPackage,
grants: crate::grants::SessionGrants,
registry: Registry,
abort_rx: StopReceiver,
compositor_tx: Option<CompositorSender>,
) -> anyhow::Result<()> {
let mut abort_rx = abort_rx;
let app_id = package.app_id.clone();
let app_id = app_id.as_str();
let image = package.image.take();
let bin = match std::env::var("WEFT_RUNTIME_BIN") {
Ok(b) => b,
Err(_) => {
tracing::debug!(session_id, %app_id, "WEFT_RUNTIME_BIN not set; skipping process spawn");
return stop_unstarted(&registry, session_id, image).await;
}
};
let Ok(shell_bin) = std::env::var("WEFT_APP_SHELL_BIN") else {
tracing::warn!(session_id, %app_id, "WEFT_APP_SHELL_BIN not set; no UI host to start");
return stop_unstarted(&registry, session_id, image).await;
};
let token = match random_token() {
Ok(token) => token,
Err(e) => {
tracing::error!(session_id, %app_id, error = %e, "cannot create readiness token");
return stop_unstarted(&registry, session_id, image).await;
}
};
let Some(ipc_socket_path) = crate::session_ipc_socket_path(session_id) else {
tracing::warn!(session_id, %app_id, "no runtime directory for the IPC socket");
return stop_unstarted(&registry, session_id, image).await;
};
let broadcast = registry.lock().await.broadcast().clone();
let relay = match spawn_ipc_relay(session_id, ipc_socket_path.clone(), broadcast) {
Ok((tx, relay)) => {
registry.lock().await.register_ipc_sender(session_id, tx);
relay
}
Err(e) => {
tracing::warn!(session_id, %app_id, error = %e, "cannot open the IPC socket");
return stop_unstarted(&registry, session_id, image).await;
}
};
let portal = spawn_file_portal(session_id, &grants.dirs);
let mut cmd = if systemd_cgroup_available() {
let mut c = tokio::process::Command::new("systemd-run");
c.args(SYSTEMD_SCOPE_ARGS).arg("--").arg(&bin);
c
} else {
tokio::process::Command::new(&bin)
};
cmd.arg(app_id)
.arg(session_id.to_string())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.stdin(std::process::Stdio::null())
.env(READY_TOKEN_ENV, &token)
.kill_on_drop(true);
cmd.arg("--ipc-socket").arg(&ipc_socket_path);
cmd.arg("--module").arg(&package.module);
for dir in &grants.dirs {
cmd.arg("--preopen").arg(dir.preopen_arg());
}
for capability in &grants.imports {
cmd.arg("--grant").arg(capability.to_string());
}
let mut session = OwnedSession {
session_id,
runtime: None,
app_shell: None,
portal,
relay: Some(relay),
image,
compositor_tx,
client_attached: false,
};
let mut runtime = match cmd.spawn() {
Ok(c) => c,
Err(e) => {
return session
.settle(&registry, &format!("failed to spawn runtime: {e}"))
.await;
}
};
let runtime_stdout = runtime.stdout.take().expect("stdout piped");
tokio::spawn(drain_stderr(
runtime.stderr.take().expect("stderr piped"),
session_id,
"runtime",
));
session.runtime = Some(runtime);
// The component must initialize before the UI host starts.
let runtime_stdout = match wait_for_child_ready(runtime_stdout, &token, &mut abort_rx).await {
Ok(reader) => reader,
Err(reason) => {
return session
.settle(&registry, &format!("runtime {reason}"))
.await;
}
};
tokio::spawn(drain_stdout(runtime_stdout, session_id));
// With a compositor, the app shell connects only through a connection
// the compositor received for this session, so every surface it creates
// is bound to the session.
let wayland = match &session.compositor_tx {
None => None,
Some(tx) => match attach_client(tx, session_id, app_id) {
Ok(stream) => {
session.client_attached = true;
Some(stream)
}
Err(reason) => return session.settle(&registry, &reason).await,
},
};
let bridge_token = registry.lock().await.bridge_token(session_id);
let mut app_shell = match spawn_app_shell(
&shell_bin,
session_id,
&package,
&token,
bridge_token,
wayland,
) {
Ok(child) => child,
Err(e) => {
return session
.settle(&registry, &format!("failed to spawn app shell: {e}"))
.await;
}
};
let shell_stdout = app_shell.stdout.take().expect("stdout piped");
tokio::spawn(drain_stderr(
app_shell.stderr.take().expect("stderr piped"),
session_id,
"app shell",
));
session.app_shell = Some(app_shell);
// Running requires the UI host to have presented the loaded document.
let shell_stdout = tokio::select! {
r = wait_for_child_ready(shell_stdout, &token, &mut abort_rx) => {
r.map_err(|reason| format!("app shell {reason}"))
}
status = session.runtime.as_mut().expect("runtime spawned").wait() => {
Err(format!("runtime exited before the app shell was ready ({status:?})"))
}
_ = session.relay.as_mut().expect("relay opened").ended() => {
Err("component closed its IPC connection before the session was ready".to_owned())
}
};
let shell_stdout = match shell_stdout {
Ok(reader) => reader,
Err(reason) => return session.settle(&registry, &reason).await,
};
let (cancel_tx, mut cancelled) = tokio::sync::mpsc::channel(1);
tokio::spawn(watch_app_shell_stdout(
shell_stdout,
session_id,
token.clone(),
cancel_tx,
));
{
let mut reg = registry.lock().await;
// A stop requested while starting can still be queued here, or lose
// the race with READY; the session is then stopped, not shown.
if matches!(reg.state(session_id), AppStateKind::Stopping) || abort_rx.try_recv().is_ok() {
drop(reg);
return session.settle(&registry, "startup aborted").await;
}
reg.set_state(session_id, AppStateKind::Running);
let _ = reg.broadcast().send(Response::AppReady {
session_id,
app_id: app_id.to_owned(),
});
}
tracing::info!(session_id, %app_id, "app ready");
// Whether the user asked the application to close, so that a clean exit
// afterwards, also one the application makes after declining, is a
// close on request.
let mut close_asked = false;
let reason = loop {
tokio::select! {
status = session.runtime.as_mut().expect("runtime spawned").wait() => {
break format!("runtime exited ({status:?})");
}
status = session.app_shell.as_mut().expect("app shell spawned").wait() => {
break match status {
Ok(status) if close_asked && status.success() => {
format!("closed on request; app shell exited ({status:?})")
}
status => format!("app shell exited ({status:?})"),
};
}
stop = abort_rx.recv() => match stop {
Some(Stop::Force) => break "terminated by force".to_owned(),
Some(Stop::Close) => {
close_asked = true;
match session.close(session_id, &mut cancelled, &mut abort_rx).await {
Close::Settle(reason) => break reason,
// The application keeps running, as its close
// policy allows; its window comes to the front so
// the user sees why. A later request asks again.
Close::Cancelled => {
tracing::info!(session_id, "the application declined the close");
session.focus(session_id);
}
}
}
// The senders are dropped only when appd shuts down.
None => break "appd is shutting down".to_owned(),
},
_ = session.relay.as_mut().expect("relay opened").ended() => {
break "component closed its IPC connection".to_owned();
}
}
};
session.settle(&registry, &reason).await
}
/// How a close request ended.
enum Close {
/// The session ends, for this reason.
Settle(String),
/// The application declined the close and keeps running.
Cancelled,
}
/// The app shell's report that its page declined a close, followed by the
/// session's readiness token so page output cannot fake it.
const CLOSE_CANCELLED: &str = "CLOSE_CANCELLED";
/// Passes the app shell's close reports on to the supervisor and logs
/// everything else it prints.
async fn watch_app_shell_stdout(
mut reader: BufReader<tokio::process::ChildStdout>,
session_id: u64,
token: String,
cancelled: tokio::sync::mpsc::Sender<()>,
) {
while let Ok(Some(line)) = read_child_line(&mut reader).await {
// Earlier output without a trailing newline can precede the
// report, as it can precede READY; the token alone establishes it.
if line.rsplit_once(' ').is_some_and(|(head, t)| {
head.ends_with(CLOSE_CANCELLED) && crate::ws::tokens_match(&token, t)
}) {
// One pending report is enough; the supervisor drops stale ones
// before it asks again.
let _ = cancelled.try_send(());
} else {
tracing::debug!(session_id, stdout = %line, "child stdout");
}
}
}
/// How long an application may take to close after being asked, for
/// example to save, before its processes are terminated.
pub(crate) const CLOSE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
/// Creates the session's Wayland connection and queues the compositor's end
/// for the compositor, returning the app shell's end.
fn attach_client(
tx: &CompositorSender,
session_id: u64,
app_id: &str,
) -> Result<std::os::unix::net::UnixStream, String> {
if !tx.is_connected() {
return Err("weft-compositor is not connected, so the app cannot show a window".to_owned());
}
let (shell, compositor) = std::os::unix::net::UnixStream::pair()
.map_err(|e| format!("cannot create the app's Wayland connection: {e}"))?;
tx.try_send(crate::compositor_client::Outbound {
msg: AppdToCompositor::AttachClient {
session_id,
app_id: app_id.to_owned(),
},
fd: Some(compositor.into()),
})
.map_err(|_| "the compositor connection is not available".to_owned())?;
Ok(shell)
}
/// Marks a session that never started any process as stopped.
async fn stop_unstarted(
registry: &Registry,
session_id: u64,
image: Option<Mount>,
) -> anyhow::Result<()> {
release_image(image).await;
let mut reg = registry.lock().await;
reg.set_state(session_id, AppStateKind::Stopped);
reg.remove_abort_sender(session_id);
let _ = reg.broadcast().send(Response::AppState {
session_id,
state: AppStateKind::Stopped,
});
Ok(())
}
/// The processes, IPC relay, portal, compositor association and image mount
/// a session owns. `settle` releases all of them on every exit path: spawn
/// failure, readiness failure, timeout, abort and child exit.
struct OwnedSession {
session_id: u64,
runtime: Option<tokio::process::Child>,
app_shell: Option<tokio::process::Child>,
portal: Option<(PathBuf, tokio::process::Child)>,
relay: Option<IpcRelay>,
/// The mounted package image, released after both children have exited.
image: Option<Mount>,
compositor_tx: Option<CompositorSender>,
/// Whether the compositor was given this session's client connection.
client_attached: bool,
}
impl OwnedSession {
/// Closes a running session as a user close would: the compositor asks
/// its windows to close and the app shell gets `CLOSE_TIMEOUT` to exit by
/// itself. Returns the terminal reason; settling terminates whatever is
/// still running.
async fn close(
&mut self,
session_id: u64,
cancelled: &mut tokio::sync::mpsc::Receiver<()>,
stops: &mut StopReceiver,
) -> Close {
// A report already read from an earlier close, for example one the
// user started in the compositor, does not answer this one. One
// still in the pipe can: the session then reads as declined while
// the app shell is still asking, and the app shell's own answer
// timeout still closes a page that does not answer.
while cancelled.try_recv().is_ok() {}
let asked = self.client_attached
&& self.compositor_tx.as_ref().is_some_and(|tx| {
tx.is_connected()
&& tx
.try_send(AppdToCompositor::AppCloseRequest { session_id }.into())
.is_ok()
});
if !asked {
return Close::Settle(
"terminate requested; the compositor could not ask the app to close".to_owned(),
);
}
let (Some(app_shell), Some(runtime), Some(relay)) = (
self.app_shell.as_mut(),
self.runtime.as_mut(),
self.relay.as_mut(),
) else {
return Close::Settle("terminate requested".to_owned());
};
let wait = async {
loop {
tokio::select! {
status = app_shell.wait() => break Close::Settle(match status {
Ok(status) if status.success() => {
format!("closed on request; app shell exited ({status:?})")
}
status => format!("app shell failed while closing ({status:?})"),
}),
status = runtime.wait() => {
break Close::Settle(format!("runtime exited while closing ({status:?})"));
}
_ = relay.ended() => break Close::Settle(
"component closed its IPC connection while closing".to_owned(),
),
Some(()) = cancelled.recv() => break Close::Cancelled,
stop = stops.recv() => match stop {
// Asking again while the application answers changes
// nothing.
Some(Stop::Close) => {}
Some(Stop::Force) => {
break Close::Settle("terminated by force while closing".to_owned());
}
None => break Close::Settle("appd is shutting down".to_owned()),
},
}
}
};
tokio::time::timeout(CLOSE_TIMEOUT, wait)
.await
.unwrap_or_else(|_| {
Close::Settle(format!(
"close requested; the app shell did not exit within {} s and was terminated",
CLOSE_TIMEOUT.as_secs()
))
})
}
/// Brings the session's window to the front with keyboard focus.
fn focus(&self, session_id: u64) {
if self.client_attached
&& let Some(tx) = &self.compositor_tx
{
let _ = tx.try_send(AppdToCompositor::AppFocusRequest { session_id }.into());
}
}
async fn settle(self, registry: &Registry, reason: &str) -> anyhow::Result<()> {
let session_id = self.session_id;
tracing::info!(session_id, reason, "stopping session");
{
let mut reg = registry.lock().await;
if !matches!(reg.state(session_id), AppStateKind::Stopping) {
reg.set_state(session_id, AppStateKind::Stopping);
let _ = reg.broadcast().send(Response::AppState {
session_id,
state: AppStateKind::Stopping,
});
}
}
kill_child(self.app_shell).await;
kill_child(self.runtime).await;
if self.client_attached
&& let Some(tx) = &self.compositor_tx
&& tx
.try_send(AppdToCompositor::AppSurfaceDestroyed { session_id }.into())
.is_err()
{
tracing::warn!(
session_id,
"compositor queue unavailable; surface not released"
);
}
release_image(self.image).await;
kill_portal(self.portal).await;
drop(self.relay);
let mut reg = registry.lock().await;
reg.remove_ipc_sender(session_id);
reg.set_state(session_id, AppStateKind::Stopped);
reg.remove_abort_sender(session_id);
let _ = reg.broadcast().send(Response::AppState {
session_id,
state: AppStateKind::Stopped,
});
Ok(())
}
}
/// Unmounts a package image without blocking the async workers.
async fn release_image(image: Option<Mount>) {
if let Some(image) = image {
let _ = tokio::task::spawn_blocking(move || drop(image)).await;
}
}
async fn kill_child(child: Option<tokio::process::Child>) {
if let Some(mut child) = child {
let _ = child.kill().await;
}
}
/// Waits for a child to print `READY <token>`, for at most READY_TIMEOUT.
/// Returns why it did not become ready otherwise.
async fn wait_for_child_ready(
stdout: tokio::process::ChildStdout,
token: &str,
abort_rx: &mut StopReceiver,
) -> Result<BufReader<tokio::process::ChildStdout>, String> {
tokio::select! {
r = tokio::time::timeout(READY_TIMEOUT, wait_for_ready(stdout, token)) => match r {
Ok(Ok(reader)) => Ok(reader),
Ok(Err(e)) => Err(format!("did not become ready: {e}")),
Err(_) => Err(format!("not ready after {}s", READY_TIMEOUT.as_secs())),
},
// Any stop request, or appd shutting down, ends a startup.
_ = abort_rx.recv() => Err("startup aborted".to_owned()),
}
}
async fn wait_for_ready(
stdout: tokio::process::ChildStdout,
token: &str,
) -> anyhow::Result<BufReader<tokio::process::ChildStdout>> {
let expected = format!("READY {token}");
let mut reader = BufReader::new(stdout);
loop {
match read_child_line(&mut reader).await? {
None => return Err(anyhow::anyhow!("stdout closed without READY signal")),
// Earlier output without a trailing newline can precede the
// readiness line; the secret token alone establishes it.
Some(line) if line.ends_with(&expected) => return Ok(reader),
Some(_) => {}
}
}
}
async fn drain_stdout(mut reader: BufReader<tokio::process::ChildStdout>, session_id: u64) {
while let Ok(Some(line)) = read_child_line(&mut reader).await {
tracing::debug!(session_id, stdout = %line, "child stdout");
}
}
async fn drain_stderr(stderr: tokio::process::ChildStderr, session_id: u64, process: &str) {
let mut reader = BufReader::new(stderr);
while let Ok(Some(line)) = read_child_line(&mut reader).await {
tracing::info!(session_id, process, stderr = %line, "child stderr");
}
}
#[cfg(all(test, target_os = "linux"))]
mod tests {
use super::SYSTEMD_SCOPE_ARGS;
fn relay_socket(name: &str) -> std::path::PathBuf {
std::env::temp_dir().join(format!("weft-relay-{name}-{}.sock", std::process::id()))
}
#[tokio::test]
async fn a_message_from_the_page_does_not_split_one_from_the_component() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let path = relay_socket("split");
let (broadcast, mut messages) = tokio::sync::broadcast::channel(16);
let (to_component, mut relay) = super::spawn_ipc_relay(7, path.clone(), broadcast).unwrap();
let mut component = tokio::net::UnixStream::connect(&path).await.unwrap();
component.write_all(b"{\"half\":").await.unwrap();
// The relay starts reading the component's message, then the page's
// message wins the select.
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
to_component.send("from the page".to_owned()).await.unwrap();
let mut received = vec![0; 14];
component.read_exact(&mut received).await.unwrap();
assert_eq!(received, b"from the page\n");
component.write_all(b"\"whole\"}\n").await.unwrap();
let message = tokio::time::timeout(std::time::Duration::from_secs(5), messages.recv())
.await
.unwrap()
.unwrap();
assert!(
matches!(&message, crate::ipc::Response::IpcMessage { session_id: 7, payload } if payload == "{\"half\":\"whole\"}"),
"{message:?}"
);
// A message at the limit, ending in a carriage return and line
// feed, arrives whole.
let mut at_limit = vec![b'y'; super::MAX_RELAY_FRAME - 2];
at_limit.extend_from_slice(b"\r\n");
component.write_all(&at_limit).await.unwrap();
let message = tokio::time::timeout(std::time::Duration::from_secs(5), messages.recv())
.await
.unwrap()
.unwrap();
assert!(
matches!(&message, crate::ipc::Response::IpcMessage { payload, .. } if payload.len() == super::MAX_RELAY_FRAME - 2),
"a message at the limit did not arrive whole"
);
// A line longer than any message ends the relay, even when its line
// break comes in the same read.
let mut over = vec![b'x'; super::MAX_RELAY_FRAME];
over.push(b'\n');
component.write_all(&over).await.unwrap();
tokio::time::timeout(std::time::Duration::from_secs(5), relay.ended())
.await
.expect("the relay did not end on an overlong line");
assert!(messages.try_recv().is_err());
drop(relay);
assert!(!path.exists());
}
/// systemd-run checks its options and their combinations before it
/// connects to the service manager. Run against an empty runtime
/// directory and bus address, it must get as far as the connection
/// attempt; any option error ends earlier with a different message. This
/// does not validate the `-p` property values, which only the manager
/// checks, and never starts a real scope.
#[test]
fn systemd_run_accepts_scope_options() {
let empty = std::env::temp_dir().join(format!("weft-scope-test-{}", std::process::id()));
std::fs::create_dir_all(&empty).unwrap();
let output = std::process::Command::new("systemd-run")
.args(SYSTEMD_SCOPE_ARGS)
.args(["--", "true"])
.env_clear()
.env("PATH", std::env::var_os("PATH").unwrap_or_default())
.env("LC_ALL", "C")
.env("XDG_RUNTIME_DIR", &empty)
.env(
"DBUS_SESSION_BUS_ADDRESS",
format!("unix:path={}/bus", empty.display()),
)
.output();
std::fs::remove_dir_all(&empty).unwrap();
let output = output.expect("systemd-run is required to check the scope options");
let stderr = String::from_utf8_lossy(&output.stderr);
// systemd 255 says "Failed to connect to bus"; later releases name the
// transport, e.g. "Failed to connect to user scope bus via local transport".
assert!(
stderr.starts_with("Failed to connect to"),
"systemd-run did not reach the manager connection: {stderr}"
);
}
}