mirror of
https://github.com/marcoallegretti/WEFT_OS.git
synced 2026-11-22 08:13:59 +00:00
912 lines
35 KiB
Rust
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(®istry, 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(®istry, 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(®istry, 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(®istry, 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(®istry, 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(®istry, &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(®istry, &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(®istry, &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(®istry, &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(®istry, &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(®istry, "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(®istry, &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}"
|
|
);
|
|
}
|
|
}
|