mirror of
https://github.com/marcoallegretti/WEFT_OS.git
synced 2026-11-22 08:13:59 +00:00
Merge pull request #9: report sessions running only after the UI host is ready
Sessions become Running only after token-authenticated READY from the runtime and the app shell, and every exit path shares one teardown.
This commit is contained in:
commit
5174a58d47
6 changed files with 496 additions and 156 deletions
|
|
@ -10,7 +10,7 @@ WEFT OS is a Wayland compositor and application runtime where every app is a Web
|
||||||
|
|
||||||
**App shell** — `weft-app-shell` is a per-process Servo host for application WebViews. It resolves `weft-app://<id>/ui/index.html`, injects a `weftIpc` WebSocket bridge into the page, and registers with the compositor as an application surface. Also feature-gated behind `servo-embed`.
|
**App shell** — `weft-app-shell` is a per-process Servo host for application WebViews. It resolves `weft-app://<id>/ui/index.html`, injects a `weftIpc` WebSocket bridge into the page, and registers with the compositor as an application surface. Also feature-gated behind `servo-embed`.
|
||||||
|
|
||||||
**App daemon** — `weft-appd` supervises sessions: spawns `weft-runtime`, waits for READY, spawns `weft-app-shell`, manages the per-session IPC relay between the Wasm component and the WebView, and handles session teardown. Wraps processes in systemd scopes (`CPUQuota=200%`, `MemoryMax=512M`) when available.
|
**App daemon** — `weft-appd` supervises sessions: spawns `weft-runtime`, waits for its READY, spawns `weft-app-shell` and reports the session running only after the app shell's READY, manages the per-session IPC relay between the Wasm component and the WebView, and handles session teardown. Wraps processes in systemd scopes (`CPUQuota=200%`, `MemoryMax=512M`) when available.
|
||||||
|
|
||||||
**Runtime** — `weft-runtime` runs WASI Component Model binaries under Wasmtime 30 (`--features wasmtime-runtime`). Provides `weft:app/notify`, `weft:app/ipc`, `weft:app/fetch`, `weft:app/notifications`, and `weft:app/clipboard` host imports. Preopens filesystem paths according to declared capabilities.
|
**Runtime** — `weft-runtime` runs WASI Component Model binaries under Wasmtime 30 (`--features wasmtime-runtime`). Provides `weft:app/notify`, `weft:app/ipc`, `weft:app/fetch`, `weft:app/notifications`, and `weft:app/clipboard` host imports. Preopens filesystem paths according to declared capabilities.
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -89,6 +89,15 @@ impl WebViewDelegate for WeftWebViewDelegate {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The readiness line for weft-appd: `READY <token>` with the session token
|
||||||
|
/// from `WEFT_READY_TOKEN`, or `READY` when run without appd.
|
||||||
|
fn ready_line() -> String {
|
||||||
|
match std::env::var("WEFT_READY_TOKEN") {
|
||||||
|
Ok(token) => format!("READY {token}"),
|
||||||
|
Err(_) => "READY".to_owned(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// Servo preferences shared by the WEFT hosts.
|
/// Servo preferences shared by the WEFT hosts.
|
||||||
fn host_preferences() -> servo::Preferences {
|
fn host_preferences() -> servo::Preferences {
|
||||||
servo::Preferences {
|
servo::Preferences {
|
||||||
|
|
@ -243,7 +252,7 @@ impl App {
|
||||||
}
|
}
|
||||||
if !self.ready_signalled && self.signals.settled.load(Ordering::Relaxed) {
|
if !self.ready_signalled && self.signals.settled.load(Ordering::Relaxed) {
|
||||||
self.ready_signalled = true;
|
self.ready_signalled = true;
|
||||||
println!("READY");
|
println!("{}", ready_line());
|
||||||
use std::io::Write;
|
use std::io::Write;
|
||||||
let _ = std::io::stdout().flush();
|
let _ = std::io::stdout().flush();
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -853,14 +853,28 @@ mod tests {
|
||||||
let _env = env_lock().lock().await;
|
let _env = env_lock().lock().await;
|
||||||
let script =
|
let script =
|
||||||
std::env::temp_dir().join(format!("weft_test_runtime_{}.sh", std::process::id()));
|
std::env::temp_dir().join(format!("weft_test_runtime_{}.sh", std::process::id()));
|
||||||
std::fs::write(&script, "#!/bin/sh\necho READY\nsleep 1\n").unwrap();
|
std::fs::write(
|
||||||
|
&script,
|
||||||
|
"#!/bin/sh\necho READY $WEFT_READY_TOKEN\nexec sleep 1\n",
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
|
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
|
|
||||||
|
let shell = std::env::temp_dir().join(format!("weft_test_shell_{}.sh", std::process::id()));
|
||||||
|
std::fs::write(
|
||||||
|
&shell,
|
||||||
|
"#!/bin/sh\necho READY $WEFT_READY_TOKEN\nexec sleep 1\n",
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
std::fs::set_permissions(&shell, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
|
|
||||||
let prior = std::env::var("WEFT_RUNTIME_BIN").ok();
|
let prior = std::env::var("WEFT_RUNTIME_BIN").ok();
|
||||||
|
let prior_shell = std::env::var("WEFT_APP_SHELL_BIN").ok();
|
||||||
let prior_cgroup = std::env::var("WEFT_DISABLE_CGROUP").ok();
|
let prior_cgroup = std::env::var("WEFT_DISABLE_CGROUP").ok();
|
||||||
// SAFETY: single-threaded test (flavor = "current_thread"); no concurrent env access.
|
// SAFETY: single-threaded test (flavor = "current_thread"); no concurrent env access.
|
||||||
unsafe {
|
unsafe {
|
||||||
std::env::set_var("WEFT_RUNTIME_BIN", &script);
|
std::env::set_var("WEFT_RUNTIME_BIN", &script);
|
||||||
|
std::env::set_var("WEFT_APP_SHELL_BIN", &shell);
|
||||||
std::env::set_var("WEFT_DISABLE_CGROUP", "1");
|
std::env::set_var("WEFT_DISABLE_CGROUP", "1");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -899,12 +913,17 @@ mod tests {
|
||||||
));
|
));
|
||||||
|
|
||||||
let _ = std::fs::remove_file(&script);
|
let _ = std::fs::remove_file(&script);
|
||||||
|
let _ = std::fs::remove_file(&shell);
|
||||||
// SAFETY: single-threaded test; restoring env to prior state.
|
// SAFETY: single-threaded test; restoring env to prior state.
|
||||||
unsafe {
|
unsafe {
|
||||||
match prior {
|
match prior {
|
||||||
Some(v) => std::env::set_var("WEFT_RUNTIME_BIN", v),
|
Some(v) => std::env::set_var("WEFT_RUNTIME_BIN", v),
|
||||||
None => std::env::remove_var("WEFT_RUNTIME_BIN"),
|
None => std::env::remove_var("WEFT_RUNTIME_BIN"),
|
||||||
}
|
}
|
||||||
|
match prior_shell {
|
||||||
|
Some(v) => std::env::set_var("WEFT_APP_SHELL_BIN", v),
|
||||||
|
None => std::env::remove_var("WEFT_APP_SHELL_BIN"),
|
||||||
|
}
|
||||||
match prior_cgroup {
|
match prior_cgroup {
|
||||||
Some(v) => std::env::set_var("WEFT_DISABLE_CGROUP", v),
|
Some(v) => std::env::set_var("WEFT_DISABLE_CGROUP", v),
|
||||||
None => std::env::remove_var("WEFT_DISABLE_CGROUP"),
|
None => std::env::remove_var("WEFT_DISABLE_CGROUP"),
|
||||||
|
|
@ -1079,4 +1098,213 @@ mod tests {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Outcome of one supervised session with scripted runtime and app shell.
|
||||||
|
#[cfg(unix)]
|
||||||
|
struct SessionRun {
|
||||||
|
notifications: Vec<Response>,
|
||||||
|
state: AppStateKind,
|
||||||
|
elapsed: std::time::Duration,
|
||||||
|
runtime_pid: Option<i32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Runs `supervise` with shell scripts standing in for weft-runtime and
|
||||||
|
/// weft-app-shell. The runtime script's PID is recorded so a test can check
|
||||||
|
/// that the session did not leave it running.
|
||||||
|
#[cfg(unix)]
|
||||||
|
async fn run_scripted_session(runtime_body: &str, shell_body: Option<&str>) -> SessionRun {
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
|
|
||||||
|
let dir = std::env::temp_dir().join(format!(
|
||||||
|
"weft_session_{}_{}",
|
||||||
|
std::process::id(),
|
||||||
|
SESSION_RUN.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
|
||||||
|
));
|
||||||
|
std::fs::create_dir_all(&dir).unwrap();
|
||||||
|
let pid_file = dir.join("runtime.pid");
|
||||||
|
let write = |name: &str, body: &str| {
|
||||||
|
let path = dir.join(name);
|
||||||
|
std::fs::write(&path, format!("#!/bin/sh\n{body}\n")).unwrap();
|
||||||
|
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||||
|
path
|
||||||
|
};
|
||||||
|
let runtime = write(
|
||||||
|
"runtime.sh",
|
||||||
|
&format!("echo $$ > {}\n{runtime_body}", pid_file.display()),
|
||||||
|
);
|
||||||
|
let shell = shell_body.map(|body| write("shell.sh", body));
|
||||||
|
|
||||||
|
let _restore = RestoreOnDrop {
|
||||||
|
prior: SCRIPTED_ENV
|
||||||
|
.iter()
|
||||||
|
.map(|n| (*n, std::env::var(n).ok()))
|
||||||
|
.collect(),
|
||||||
|
dir: dir.clone(),
|
||||||
|
};
|
||||||
|
// SAFETY: callers hold env_lock and use a current_thread runtime.
|
||||||
|
unsafe {
|
||||||
|
std::env::set_var("WEFT_RUNTIME_BIN", &runtime);
|
||||||
|
match &shell {
|
||||||
|
Some(path) => std::env::set_var("WEFT_APP_SHELL_BIN", path),
|
||||||
|
None => std::env::remove_var("WEFT_APP_SHELL_BIN"),
|
||||||
|
}
|
||||||
|
std::env::set_var("WEFT_DISABLE_CGROUP", "1");
|
||||||
|
}
|
||||||
|
|
||||||
|
let registry = make_registry();
|
||||||
|
let mut rx = registry.lock().await.subscribe();
|
||||||
|
let session_id = registry.lock().await.launch("test.app");
|
||||||
|
let abort_rx = registry.lock().await.register_abort(session_id);
|
||||||
|
let started = std::time::Instant::now();
|
||||||
|
tokio::time::timeout(
|
||||||
|
std::time::Duration::from_secs(20),
|
||||||
|
runtime::supervise(
|
||||||
|
session_id,
|
||||||
|
"test.app",
|
||||||
|
Arc::clone(®istry),
|
||||||
|
abort_rx,
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
.expect("session did not settle")
|
||||||
|
.unwrap();
|
||||||
|
let elapsed = started.elapsed();
|
||||||
|
|
||||||
|
let mut notifications = Vec::new();
|
||||||
|
while let Ok(n) = rx.try_recv() {
|
||||||
|
notifications.push(n);
|
||||||
|
}
|
||||||
|
let state = registry.lock().await.state(session_id);
|
||||||
|
let runtime_pid = std::fs::read_to_string(&pid_file)
|
||||||
|
.ok()
|
||||||
|
.and_then(|s| s.trim().parse().ok());
|
||||||
|
|
||||||
|
SessionRun {
|
||||||
|
notifications,
|
||||||
|
state,
|
||||||
|
elapsed,
|
||||||
|
runtime_pid,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
static SESSION_RUN: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
const SCRIPTED_ENV: [&str; 3] = [
|
||||||
|
"WEFT_RUNTIME_BIN",
|
||||||
|
"WEFT_APP_SHELL_BIN",
|
||||||
|
"WEFT_DISABLE_CGROUP",
|
||||||
|
];
|
||||||
|
|
||||||
|
/// Restores the scripted-session environment and removes its scripts,
|
||||||
|
/// also when an assertion fails.
|
||||||
|
#[cfg(unix)]
|
||||||
|
struct RestoreOnDrop {
|
||||||
|
prior: Vec<(&'static str, Option<String>)>,
|
||||||
|
dir: std::path::PathBuf,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
impl Drop for RestoreOnDrop {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
// SAFETY: the owning test holds env_lock on a current_thread runtime.
|
||||||
|
unsafe {
|
||||||
|
for (name, value) in &self.prior {
|
||||||
|
match value {
|
||||||
|
Some(v) => std::env::set_var(name, v),
|
||||||
|
None => std::env::remove_var(name),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let _ = std::fs::remove_dir_all(&self.dir);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
fn became_ready(run: &SessionRun) -> bool {
|
||||||
|
run.notifications
|
||||||
|
.iter()
|
||||||
|
.any(|n| matches!(n, Response::AppReady { .. }))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
fn process_alive(pid: i32) -> bool {
|
||||||
|
std::path::Path::new(&format!("/proc/{pid}")).exists()
|
||||||
|
&& !std::fs::read_to_string(format!("/proc/{pid}/stat"))
|
||||||
|
.map(|stat| stat.split_whitespace().nth(2) == Some("Z"))
|
||||||
|
.unwrap_or(true)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
#[tokio::test(flavor = "current_thread")]
|
||||||
|
async fn session_is_not_ready_until_app_shell_is_ready() {
|
||||||
|
let _env = env_lock().lock().await;
|
||||||
|
let run = run_scripted_session(
|
||||||
|
"echo READY $WEFT_READY_TOKEN\nexec sleep 30",
|
||||||
|
Some("sleep 0.3\nexit 1"),
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
assert!(!became_ready(&run), "{:?}", run.notifications);
|
||||||
|
assert!(matches!(run.state, AppStateKind::Stopped));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
#[tokio::test(flavor = "current_thread")]
|
||||||
|
async fn session_stops_when_runtime_exits_before_app_shell_is_ready() {
|
||||||
|
let _env = env_lock().lock().await;
|
||||||
|
let run = run_scripted_session(
|
||||||
|
"echo READY $WEFT_READY_TOKEN\nexit 0",
|
||||||
|
Some("exec sleep 30"),
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
assert!(!became_ready(&run), "{:?}", run.notifications);
|
||||||
|
assert!(matches!(run.state, AppStateKind::Stopped));
|
||||||
|
assert!(run.elapsed < std::time::Duration::from_secs(10));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
#[tokio::test(flavor = "current_thread")]
|
||||||
|
async fn session_without_app_shell_never_becomes_ready() {
|
||||||
|
let _env = env_lock().lock().await;
|
||||||
|
let run = run_scripted_session("echo READY $WEFT_READY_TOKEN\nexec sleep 30", None).await;
|
||||||
|
assert!(!became_ready(&run), "{:?}", run.notifications);
|
||||||
|
assert!(matches!(run.state, AppStateKind::Stopped));
|
||||||
|
assert!(
|
||||||
|
run.runtime_pid.is_none(),
|
||||||
|
"runtime started without a UI host"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
#[tokio::test(flavor = "current_thread")]
|
||||||
|
async fn readiness_requires_the_session_token() {
|
||||||
|
let _env = env_lock().lock().await;
|
||||||
|
// Application output can contain READY lines; only the token counts.
|
||||||
|
let run = run_scripted_session(
|
||||||
|
"echo READY $WEFT_READY_TOKEN\nexec sleep 30",
|
||||||
|
Some("echo READY\necho READY 0123456789abcdef\nsleep 0.3"),
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
assert!(!became_ready(&run), "{:?}", run.notifications);
|
||||||
|
assert!(matches!(run.state, AppStateKind::Stopped));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
#[tokio::test(flavor = "current_thread")]
|
||||||
|
async fn app_shell_exit_ends_running_session_and_runtime() {
|
||||||
|
let _env = env_lock().lock().await;
|
||||||
|
let run = run_scripted_session(
|
||||||
|
"echo READY $WEFT_READY_TOKEN\nexec sleep 30",
|
||||||
|
Some("echo READY $WEFT_READY_TOKEN\nexec sleep 0.3"),
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
assert!(became_ready(&run), "{:?}", run.notifications);
|
||||||
|
assert!(matches!(run.state, AppStateKind::Stopped));
|
||||||
|
assert!(run.elapsed < std::time::Duration::from_secs(10));
|
||||||
|
let pid = run.runtime_pid.expect("runtime started");
|
||||||
|
assert!(!process_alive(pid), "runtime {pid} left running");
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -70,6 +70,42 @@ pub(crate) async fn spawn_ipc_relay(
|
||||||
|
|
||||||
const READY_TIMEOUT: Duration = Duration::from_secs(30);
|
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";
|
||||||
|
|
||||||
|
/// Longest line read from a child's output; longer lines are split.
|
||||||
|
const MAX_LINE: u64 = 64 * 1024;
|
||||||
|
|
||||||
|
fn readiness_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.
|
/// `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,
|
/// A scope runs the command in the foreground as systemd-run's own process,
|
||||||
|
|
@ -171,31 +207,23 @@ async fn kill_portal(portal: Option<(PathBuf, tokio::process::Child)>) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
async fn spawn_app_shell(session_id: u64, app_id: &str) -> Option<tokio::process::Child> {
|
fn spawn_app_shell(
|
||||||
let bin = std::env::var("WEFT_APP_SHELL_BIN").ok()?;
|
bin: &str,
|
||||||
let mut cmd = tokio::process::Command::new(&bin);
|
session_id: u64,
|
||||||
cmd.arg(app_id)
|
app_id: &str,
|
||||||
|
token: &str,
|
||||||
|
) -> std::io::Result<tokio::process::Child> {
|
||||||
|
let child = tokio::process::Command::new(bin)
|
||||||
|
.arg(app_id)
|
||||||
.arg(session_id.to_string())
|
.arg(session_id.to_string())
|
||||||
|
.env(READY_TOKEN_ENV, token)
|
||||||
.stdin(std::process::Stdio::null())
|
.stdin(std::process::Stdio::null())
|
||||||
.stdout(std::process::Stdio::null())
|
.stdout(std::process::Stdio::piped())
|
||||||
.stderr(std::process::Stdio::null());
|
.stderr(std::process::Stdio::piped())
|
||||||
match cmd.spawn() {
|
.kill_on_drop(true)
|
||||||
Ok(child) => {
|
.spawn()?;
|
||||||
tracing::info!(session_id, %app_id, bin = %bin, "app shell spawned");
|
tracing::info!(session_id, %app_id, bin, "app shell spawned");
|
||||||
Some(child)
|
Ok(child)
|
||||||
}
|
|
||||||
Err(e) => {
|
|
||||||
tracing::warn!(session_id, %app_id, error = %e, "failed to spawn app shell");
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn kill_app_shell(child: Option<tokio::process::Child>) {
|
|
||||||
if let Some(mut c) = child {
|
|
||||||
let _ = c.kill().await;
|
|
||||||
let _ = c.wait().await;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn portal_socket_path(session_id: u64) -> Option<PathBuf> {
|
fn portal_socket_path(session_id: u64) -> Option<PathBuf> {
|
||||||
|
|
@ -219,7 +247,7 @@ fn spawn_file_portal(
|
||||||
for (host, _) in allowed_paths {
|
for (host, _) in allowed_paths {
|
||||||
cmd.arg("--allow").arg(host);
|
cmd.arg("--allow").arg(host);
|
||||||
}
|
}
|
||||||
let child = cmd.spawn().ok()?;
|
let child = cmd.kill_on_drop(true).spawn().ok()?;
|
||||||
tracing::info!(session_id, socket = %socket.display(), "file portal spawned");
|
tracing::info!(session_id, socket = %socket.display(), "file portal spawned");
|
||||||
Some((socket, child))
|
Some((socket, child))
|
||||||
}
|
}
|
||||||
|
|
@ -237,14 +265,19 @@ pub(crate) async fn supervise(
|
||||||
Ok(b) => b,
|
Ok(b) => b,
|
||||||
Err(_) => {
|
Err(_) => {
|
||||||
tracing::debug!(session_id, %app_id, "WEFT_RUNTIME_BIN not set; skipping process spawn");
|
tracing::debug!(session_id, %app_id, "WEFT_RUNTIME_BIN not set; skipping process spawn");
|
||||||
let mut reg = registry.lock().await;
|
return stop_unstarted(®istry, session_id).await;
|
||||||
reg.set_state(session_id, AppStateKind::Stopped);
|
}
|
||||||
reg.remove_abort_sender(session_id);
|
};
|
||||||
let _ = reg.broadcast().send(Response::AppState {
|
|
||||||
session_id,
|
let Ok(shell_bin) = std::env::var("WEFT_APP_SHELL_BIN") else {
|
||||||
state: AppStateKind::Stopped,
|
tracing::warn!(session_id, %app_id, "WEFT_APP_SHELL_BIN not set; no UI host to start");
|
||||||
});
|
return stop_unstarted(®istry, session_id).await;
|
||||||
return Ok(());
|
};
|
||||||
|
let token = match readiness_token() {
|
||||||
|
Ok(token) => token,
|
||||||
|
Err(e) => {
|
||||||
|
tracing::error!(session_id, %app_id, error = %e, "cannot create readiness token");
|
||||||
|
return stop_unstarted(®istry, session_id).await;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
@ -265,7 +298,9 @@ pub(crate) async fn supervise(
|
||||||
.arg(session_id.to_string())
|
.arg(session_id.to_string())
|
||||||
.stdout(std::process::Stdio::piped())
|
.stdout(std::process::Stdio::piped())
|
||||||
.stderr(std::process::Stdio::piped())
|
.stderr(std::process::Stdio::piped())
|
||||||
.stdin(std::process::Stdio::null());
|
.stdin(std::process::Stdio::null())
|
||||||
|
.env(READY_TOKEN_ENV, &token)
|
||||||
|
.kill_on_drop(true);
|
||||||
|
|
||||||
if let Some(ref sock) = ipc_socket_path {
|
if let Some(ref sock) = ipc_socket_path {
|
||||||
cmd.arg("--ipc-socket").arg(sock);
|
cmd.arg("--ipc-socket").arg(sock);
|
||||||
|
|
@ -283,42 +318,91 @@ pub(crate) async fn supervise(
|
||||||
cmd.arg("--preopen").arg(format!("{host}::{guest}"));
|
cmd.arg("--preopen").arg(format!("{host}::{guest}"));
|
||||||
}
|
}
|
||||||
|
|
||||||
let mut child = match cmd.spawn() {
|
let mut session = OwnedSession {
|
||||||
Ok(c) => c,
|
|
||||||
Err(e) => {
|
|
||||||
tracing::warn!(session_id, %app_id, error = %e, "failed to spawn runtime; marking session stopped");
|
|
||||||
kill_portal(portal).await;
|
|
||||||
let mut reg = registry.lock().await;
|
|
||||||
reg.set_state(session_id, AppStateKind::Stopped);
|
|
||||||
let _ = reg.broadcast().send(Response::AppState {
|
|
||||||
session_id,
|
session_id,
|
||||||
state: AppStateKind::Stopped,
|
runtime: None,
|
||||||
});
|
app_shell: None,
|
||||||
return Ok(());
|
portal,
|
||||||
}
|
mount: mount_orch,
|
||||||
|
compositor_tx,
|
||||||
|
surface_announced: false,
|
||||||
};
|
};
|
||||||
|
|
||||||
if let Some(tx) = &compositor_tx {
|
let mut runtime = match cmd.spawn() {
|
||||||
let pid = child.id().unwrap_or(0);
|
Ok(c) => c,
|
||||||
let _ = tx
|
Err(e) => {
|
||||||
.send(AppdToCompositor::AppSurfaceCreated {
|
return session
|
||||||
|
.settle(®istry, &format!("failed to spawn runtime: {e}"))
|
||||||
|
.await;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
if let Some(tx) = &session.compositor_tx {
|
||||||
|
let pid = runtime.id().unwrap_or(0);
|
||||||
|
// A full queue (compositor disconnected) must not stall the session.
|
||||||
|
session.surface_announced = tx
|
||||||
|
.try_send(AppdToCompositor::AppSurfaceCreated {
|
||||||
app_id: app_id.to_owned(),
|
app_id: app_id.to_owned(),
|
||||||
session_id,
|
session_id,
|
||||||
pid,
|
pid,
|
||||||
})
|
})
|
||||||
|
.is_ok();
|
||||||
|
if !session.surface_announced {
|
||||||
|
tracing::warn!(
|
||||||
|
session_id,
|
||||||
|
"compositor queue unavailable; surface not announced"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
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;
|
.await;
|
||||||
}
|
}
|
||||||
|
|
||||||
let stdout = child.stdout.take().expect("stdout piped");
|
|
||||||
let stderr = child.stderr.take().expect("stderr piped");
|
|
||||||
|
|
||||||
let ready_result = tokio::select! {
|
|
||||||
r = tokio::time::timeout(READY_TIMEOUT, wait_for_ready(stdout)) => Some(r),
|
|
||||||
_ = &mut abort_rx => None,
|
|
||||||
};
|
};
|
||||||
|
tokio::spawn(drain_stdout(runtime_stdout, session_id));
|
||||||
|
|
||||||
|
let mut app_shell = match spawn_app_shell(&shell_bin, session_id, app_id, &token) {
|
||||||
|
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:?})"))
|
||||||
|
}
|
||||||
|
};
|
||||||
|
let shell_stdout = match shell_stdout {
|
||||||
|
Ok(reader) => reader,
|
||||||
|
Err(reason) => return session.settle(®istry, &reason).await,
|
||||||
|
};
|
||||||
|
tokio::spawn(drain_stdout(shell_stdout, session_id));
|
||||||
|
|
||||||
let app_shell = match ready_result {
|
|
||||||
Some(Ok(Ok(remaining_stdout))) => {
|
|
||||||
{
|
{
|
||||||
let mut reg = registry.lock().await;
|
let mut reg = registry.lock().await;
|
||||||
reg.set_state(session_id, AppStateKind::Running);
|
reg.set_state(session_id, AppStateKind::Running);
|
||||||
|
|
@ -328,74 +412,21 @@ pub(crate) async fn supervise(
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
tracing::info!(session_id, %app_id, "app ready");
|
tracing::info!(session_id, %app_id, "app ready");
|
||||||
tokio::spawn(drain_stdout(remaining_stdout, session_id));
|
|
||||||
spawn_app_shell(session_id, app_id).await
|
let reason = tokio::select! {
|
||||||
|
status = session.runtime.as_mut().expect("runtime spawned").wait() => {
|
||||||
|
format!("runtime exited ({status:?})")
|
||||||
}
|
}
|
||||||
Some(Ok(Err(e))) => {
|
status = session.app_shell.as_mut().expect("app shell spawned").wait() => {
|
||||||
tracing::warn!(session_id, %app_id, error = %e, "stdout read error before READY; killing process");
|
format!("app shell exited ({status:?})")
|
||||||
let _ = child.kill().await;
|
|
||||||
kill_portal(portal).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,
|
|
||||||
});
|
|
||||||
return Ok(());
|
|
||||||
}
|
|
||||||
Some(Err(_elapsed)) => {
|
|
||||||
tracing::warn!(session_id, %app_id, "READY timeout after 30s; killing process");
|
|
||||||
let _ = child.kill().await;
|
|
||||||
kill_portal(portal).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,
|
|
||||||
});
|
|
||||||
return Ok(());
|
|
||||||
}
|
|
||||||
None => {
|
|
||||||
tracing::info!(session_id, %app_id, "abort during startup; killing process");
|
|
||||||
let _ = child.kill().await;
|
|
||||||
kill_portal(portal).await;
|
|
||||||
let mut reg = registry.lock().await;
|
|
||||||
reg.set_state(session_id, AppStateKind::Stopped);
|
|
||||||
let _ = reg.broadcast().send(Response::AppState {
|
|
||||||
session_id,
|
|
||||||
state: AppStateKind::Stopped,
|
|
||||||
});
|
|
||||||
return Ok(());
|
|
||||||
}
|
}
|
||||||
|
_ = &mut abort_rx => "terminate requested".to_owned(),
|
||||||
};
|
};
|
||||||
|
session.settle(®istry, &reason).await
|
||||||
|
}
|
||||||
|
|
||||||
tokio::spawn(drain_stderr(stderr, session_id));
|
/// Marks a session that never started any process as stopped.
|
||||||
|
async fn stop_unstarted(registry: &Registry, session_id: u64) -> anyhow::Result<()> {
|
||||||
tokio::select! {
|
|
||||||
status = child.wait() => {
|
|
||||||
tracing::info!(session_id, %app_id, exit_status = ?status, "process exited");
|
|
||||||
}
|
|
||||||
_ = abort_rx => {
|
|
||||||
tracing::info!(session_id, %app_id, "abort received; sending SIGTERM");
|
|
||||||
let _ = child.kill().await;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
kill_app_shell(app_shell).await;
|
|
||||||
|
|
||||||
if let Some(tx) = &compositor_tx {
|
|
||||||
let _ = tx
|
|
||||||
.send(AppdToCompositor::AppSurfaceDestroyed { session_id })
|
|
||||||
.await;
|
|
||||||
}
|
|
||||||
|
|
||||||
mount_orch.umount();
|
|
||||||
|
|
||||||
kill_portal(portal).await;
|
|
||||||
|
|
||||||
{
|
|
||||||
let mut reg = registry.lock().await;
|
let mut reg = registry.lock().await;
|
||||||
reg.set_state(session_id, AppStateKind::Stopped);
|
reg.set_state(session_id, AppStateKind::Stopped);
|
||||||
reg.remove_abort_sender(session_id);
|
reg.remove_abort_sender(session_id);
|
||||||
|
|
@ -403,42 +434,103 @@ pub(crate) async fn supervise(
|
||||||
session_id,
|
session_id,
|
||||||
state: AppStateKind::Stopped,
|
state: AppStateKind::Stopped,
|
||||||
});
|
});
|
||||||
}
|
|
||||||
|
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The processes, 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. The IPC relay is not yet
|
||||||
|
/// owned here.
|
||||||
|
struct OwnedSession {
|
||||||
|
session_id: u64,
|
||||||
|
runtime: Option<tokio::process::Child>,
|
||||||
|
app_shell: Option<tokio::process::Child>,
|
||||||
|
portal: Option<(PathBuf, tokio::process::Child)>,
|
||||||
|
mount: crate::mount::MountOrchestrator,
|
||||||
|
compositor_tx: Option<CompositorSender>,
|
||||||
|
surface_announced: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl OwnedSession {
|
||||||
|
async fn settle(self, registry: &Registry, reason: &str) -> anyhow::Result<()> {
|
||||||
|
let session_id = self.session_id;
|
||||||
|
tracing::info!(session_id, reason, "stopping session");
|
||||||
|
kill_child(self.app_shell).await;
|
||||||
|
kill_child(self.runtime).await;
|
||||||
|
if self.surface_announced
|
||||||
|
&& let Some(tx) = &self.compositor_tx
|
||||||
|
&& tx
|
||||||
|
.try_send(AppdToCompositor::AppSurfaceDestroyed { session_id })
|
||||||
|
.is_err()
|
||||||
|
{
|
||||||
|
tracing::warn!(
|
||||||
|
session_id,
|
||||||
|
"compositor queue unavailable; surface not released"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
self.mount.umount();
|
||||||
|
kill_portal(self.portal).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(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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 tokio::sync::oneshot::Receiver<()>,
|
||||||
|
) -> 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())),
|
||||||
|
},
|
||||||
|
_ = abort_rx => Err("startup aborted".to_owned()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
async fn wait_for_ready(
|
async fn wait_for_ready(
|
||||||
stdout: tokio::process::ChildStdout,
|
stdout: tokio::process::ChildStdout,
|
||||||
|
token: &str,
|
||||||
) -> anyhow::Result<BufReader<tokio::process::ChildStdout>> {
|
) -> anyhow::Result<BufReader<tokio::process::ChildStdout>> {
|
||||||
|
let expected = format!("READY {token}");
|
||||||
let mut reader = BufReader::new(stdout);
|
let mut reader = BufReader::new(stdout);
|
||||||
loop {
|
loop {
|
||||||
let mut line = String::new();
|
match read_child_line(&mut reader).await? {
|
||||||
let n = reader.read_line(&mut line).await?;
|
None => return Err(anyhow::anyhow!("stdout closed without READY signal")),
|
||||||
if n == 0 {
|
// Earlier output without a trailing newline can precede the
|
||||||
return Err(anyhow::anyhow!("stdout closed without READY signal"));
|
// readiness line; the secret token alone establishes it.
|
||||||
}
|
Some(line) if line.ends_with(&expected) => return Ok(reader),
|
||||||
if line.trim() == "READY" {
|
Some(_) => {}
|
||||||
return Ok(reader);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
async fn drain_stdout(mut reader: BufReader<tokio::process::ChildStdout>, session_id: u64) {
|
async fn drain_stdout(mut reader: BufReader<tokio::process::ChildStdout>, session_id: u64) {
|
||||||
let mut line = String::new();
|
while let Ok(Some(line)) = read_child_line(&mut reader).await {
|
||||||
loop {
|
tracing::debug!(session_id, stdout = %line, "child stdout");
|
||||||
line.clear();
|
|
||||||
match reader.read_line(&mut line).await {
|
|
||||||
Ok(0) | Err(_) => break,
|
|
||||||
Ok(_) => tracing::debug!(session_id, stdout = %line.trim_end(), "app stdout"),
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
async fn drain_stderr(stderr: tokio::process::ChildStderr, session_id: u64) {
|
async fn drain_stderr(stderr: tokio::process::ChildStderr, session_id: u64, process: &str) {
|
||||||
let mut lines = BufReader::new(stderr).lines();
|
let mut reader = BufReader::new(stderr);
|
||||||
while let Ok(Some(line)) = lines.next_line().await {
|
while let Ok(Some(line)) = read_child_line(&mut reader).await {
|
||||||
tracing::warn!(session_id, stderr = %line, "app stderr");
|
tracing::info!(session_id, process, stderr = %line, "child stderr");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -70,6 +70,16 @@ fn main() -> anyhow::Result<()> {
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The readiness line for weft-appd: `READY <token>` with the session token
|
||||||
|
/// from `WEFT_READY_TOKEN`, or `READY` when run without appd.
|
||||||
|
#[cfg(feature = "wasmtime-runtime")]
|
||||||
|
fn ready_line() -> String {
|
||||||
|
match std::env::var("WEFT_READY_TOKEN") {
|
||||||
|
Ok(token) => format!("READY {token}"),
|
||||||
|
Err(_) => "READY".to_owned(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn resolve_package(app_id: &str) -> anyhow::Result<PathBuf> {
|
fn resolve_package(app_id: &str) -> anyhow::Result<PathBuf> {
|
||||||
for store_root in package_store_roots() {
|
for store_root in package_store_roots() {
|
||||||
let pkg_dir = store_root.join(app_id);
|
let pkg_dir = store_root.join(app_id);
|
||||||
|
|
@ -198,7 +208,7 @@ fn run_module(
|
||||||
.instance("weft:app/notify@0.1.0")
|
.instance("weft:app/notify@0.1.0")
|
||||||
.context("define weft:app/notify instance")?
|
.context("define weft:app/notify instance")?
|
||||||
.func_wrap("ready", |_: wasmtime::StoreContextMut<'_, State>, ()| {
|
.func_wrap("ready", |_: wasmtime::StoreContextMut<'_, State>, ()| {
|
||||||
println!("READY");
|
println!("{}", ready_line());
|
||||||
Ok::<(), wasmtime::Error>(())
|
Ok::<(), wasmtime::Error>(())
|
||||||
})
|
})
|
||||||
.context("define weft:app/notify#ready")?;
|
.context("define weft:app/notify#ready")?;
|
||||||
|
|
|
||||||
|
|
@ -20,7 +20,7 @@ Per-application Servo host. Spawned by `weft-appd` after the Wasm runtime signal
|
||||||
|
|
||||||
### weft-appd
|
### weft-appd
|
||||||
|
|
||||||
Session supervisor. Listens on a Unix socket (MessagePack protocol) and a WebSocket port (JSON). For each session: spawns `weft-runtime`, waits for READY, spawns `weft-app-shell`, manages the per-session IPC relay, and supervises child processes. Handles graceful termination and cgroup resource limits (via systemd-run when available).
|
Session supervisor. Listens on a Unix socket (MessagePack protocol) and a WebSocket port (JSON). For each session: spawns `weft-runtime` and waits for its READY, spawns `weft-app-shell` (`WEFT_APP_SHELL_BIN` is required) and waits for its READY, and only then reports the session running (`APP_READY`). A child reports readiness by printing `READY <token>` on stdout, where the token is a random per-session value appd passes in `WEFT_READY_TOKEN`; Wasm guests and pages share those stdout streams but cannot read the token, so their output cannot fake readiness. Each wait times out after 30 seconds. If either child fails to start, fails to become ready or exits, or the session is terminated, the whole session is stopped: both children, the file portal, the compositor association and any image mount are released. Manages the per-session IPC relay and applies cgroup resource limits to the runtime via systemd-run when available.
|
||||||
|
|
||||||
### weft-runtime
|
### weft-runtime
|
||||||
|
|
||||||
|
|
@ -93,7 +93,8 @@ Package store roots (in priority order):
|
||||||
| Variable | Default | Description |
|
| Variable | Default | Description |
|
||||||
|---|---|---|
|
|---|---|---|
|
||||||
| `WEFT_RUNTIME_BIN` | — | Path to `weft-runtime` binary |
|
| `WEFT_RUNTIME_BIN` | — | Path to `weft-runtime` binary |
|
||||||
| `WEFT_APP_SHELL_BIN` | — | Path to `weft-app-shell` binary |
|
| `WEFT_APP_SHELL_BIN` | — | Path to `weft-app-shell` binary; required to launch apps |
|
||||||
|
| `WEFT_READY_TOKEN` | set by appd | Per-session readiness token passed to `weft-runtime` and `weft-app-shell` |
|
||||||
| `WEFT_FILE_PORTAL_BIN` | — | Path to `weft-file-portal` binary |
|
| `WEFT_FILE_PORTAL_BIN` | — | Path to `weft-file-portal` binary |
|
||||||
| `WEFT_MOUNT_HELPER` | — | Path to `weft-mount-helper` binary |
|
| `WEFT_MOUNT_HELPER` | — | Path to `weft-mount-helper` binary |
|
||||||
| `WEFT_APP_STORE` | — | Override package store root |
|
| `WEFT_APP_STORE` | — | Override package store root |
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue