mirror of
https://github.com/marcoallegretti/WEFT_OS.git
synced 2026-11-22 08:13:59 +00:00
Every capability a package declared was granted at launch, so a signed package received all the permissions it asked for. Blueprint 5.2 rules that out. A package now gets only the capabilities the user approved. weft-pack install --approve approves those the installed package declares, and weft-pack approve <id> approves those of the installed app later. Without approval, install lists what still needs it. The approval is recorded in $XDG_DATA_HOME/weft/approvals/<id>. weft-appd refuses to launch an app declaring a capability the record does not hold, with 403 and the capabilities named, after refusing unknown or unsupported ones as before. An update that declares a new capability needs approval again, and uninstalling forgets the approval. Private app data is a minimal execution resource and needs no approval, so Notes and the existing fixtures are unchanged. Unit tests cover the approval record, install and approve, an update adding a capability, uninstall, and appd refusing and then launching. tests/frame/check_update.py launches a real app declaring notifications: it is refused until weft-pack approve, then runs.
232 lines
10 KiB
Python
Executable file
232 lines
10 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
"""Check that package updates are transactional and leave running sessions alone.
|
|
|
|
The harness installs a test application with weft-pack into a private store
|
|
and runs weft-appd with the real runtime and app shell on a nested desktop
|
|
(see session.py). Each revision of the application's page shows its own
|
|
colour. In the presented pixels and the store:
|
|
|
|
1. A session started from revision one keeps showing it after the package is
|
|
updated to revision two, and its app shell runs from revision one's own
|
|
directory, which the update keeps while the session runs.
|
|
2. An update that fails (an invalid component) changes nothing: revision two
|
|
stays active.
|
|
3. A session launched after the update shows revision two.
|
|
4. Once the first session has ended, the next update removes revision one,
|
|
and keeps revision two for rollback; `weft-pack rollback` makes revision
|
|
two active again.
|
|
5. Uninstalling while a session runs stops new launches (404) but not the
|
|
session; the next uninstall, after it has ended, removes the revisions.
|
|
6. An app declaring a capability (notifications) is refused at launch (403)
|
|
until `weft-pack approve` approves it, and then launches.
|
|
|
|
The application is unsigned development content using the Counter demo's
|
|
component.
|
|
"""
|
|
|
|
import argparse
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
from check_counter import AppdClient, free_port, read_endpoint # noqa: E402
|
|
from session import ROOT, Desktop, SessionError, bounding_box, missing_tools, parse_ppm # noqa: E402
|
|
|
|
APP_ID = "org.weft.test.update"
|
|
COLOURS = {"one": (200, 0, 0), "two": (0, 0, 200), "three": (0, 160, 0)}
|
|
VERSIONS = {"one": 1, "two": 2, "bad": 3, "three": 4}
|
|
STARTUP_TIMEOUT = 120.0
|
|
|
|
|
|
def write_revision(src, name, wasm=None, capabilities="[]"):
|
|
shutil.rmtree(src, ignore_errors=True)
|
|
(src / "ui").mkdir(parents=True)
|
|
(src / "wapp.toml").write_text(
|
|
f'[package]\nid = "{APP_ID}"\nname = "Update"\nversion = "0.0.{VERSIONS[name]}"\n'
|
|
f'capabilities = {capabilities}\n'
|
|
'[runtime]\nmodule = "app.wasm"\n[ui]\nentry = "ui/index.html"\n')
|
|
if wasm is None:
|
|
shutil.copy(ROOT / "examples/org.weft.demo.counter/app.wasm", src / "app.wasm")
|
|
else:
|
|
(src / "app.wasm").write_bytes(wasm)
|
|
colour = COLOURS.get(name, (0, 0, 0))
|
|
(src / "ui/index.html").write_text(
|
|
'<!DOCTYPE html><html><body style="margin:0;width:100vw;height:100vh;'
|
|
f'background:rgb{colour}"></body></html>')
|
|
|
|
|
|
def shows(desktop, colour, timeout=20):
|
|
deadline = time.monotonic() + timeout
|
|
while time.monotonic() < deadline:
|
|
width, height, pixels = parse_ppm(desktop.capture())
|
|
if bounding_box(width, height, pixels, colour) is not None:
|
|
return True
|
|
time.sleep(0.3)
|
|
return False
|
|
|
|
|
|
def run(args, desktop, store, home):
|
|
t = Path(args.target)
|
|
env = dict(os.environ, WEFT_APP_STORE=str(store), HOME=str(home),
|
|
XDG_DATA_HOME=str(home / "share"))
|
|
|
|
def pack(*arguments, ok=True):
|
|
done = subprocess.run([t / "weft-pack", *arguments], env=env,
|
|
capture_output=True, text=True, timeout=60)
|
|
if ok and done.returncode != 0:
|
|
raise AssertionError(f"weft-pack {' '.join(arguments)} failed: {done.stderr}")
|
|
if not ok and done.returncode == 0:
|
|
raise AssertionError(f"weft-pack {' '.join(arguments)} succeeded: {done.stdout}")
|
|
return done.stdout + done.stderr
|
|
|
|
revisions = store / ".revisions" / APP_ID
|
|
|
|
def active():
|
|
return os.readlink(store / APP_ID)
|
|
|
|
src = home / "src"
|
|
write_revision(src, "one")
|
|
pack("install", str(src), "--dev")
|
|
one = store / active()
|
|
|
|
desktop.launch_client("appd", [t / "weft-appd"], {
|
|
"WEFT_RUNTIME_BIN": str(t / "weft-runtime"),
|
|
"WEFT_APP_SHELL_BIN": str(t / "weft-app-shell"),
|
|
"WEFT_APP_STORE": str(store),
|
|
"WEFT_DISABLE_CGROUP": "1",
|
|
"WEFT_APPD_WS_PORT": str(free_port()),
|
|
"HOME": str(home),
|
|
"XDG_DATA_HOME": str(home / "share"),
|
|
})
|
|
port, token = read_endpoint(desktop.runtime, 30)
|
|
appd = AppdClient(port, token)
|
|
|
|
def launch():
|
|
appd.send({"type": "LAUNCH_APP", "app_id": APP_ID, "surface_id": 0})
|
|
reply = appd.wait_for(lambda m: m.get("type") in ("APP_READY", "ERROR"), STARTUP_TIMEOUT)
|
|
if reply.get("type") != "APP_READY":
|
|
raise AssertionError(f"the app did not start: {reply}")
|
|
return reply["session_id"]
|
|
|
|
def stop(session_id):
|
|
appd.send({"type": "TERMINATE_APP", "session_id": session_id, "force": True})
|
|
appd.wait_for(lambda m: m.get("type") == "APP_STATE" and m.get("state") == "stopped"
|
|
and m.get("session_id") == session_id, 20)
|
|
|
|
first = launch()
|
|
if not shows(desktop, COLOURS["one"]):
|
|
raise AssertionError("revision one is not shown")
|
|
shells = subprocess.run(["pgrep", "-af", "weft-app-shell"], capture_output=True,
|
|
text=True).stdout
|
|
if str(one / "ui/index.html") not in shells:
|
|
raise AssertionError(f"the app shell does not run from revision one: {shells}")
|
|
|
|
# 1. An update leaves the running session on its revision.
|
|
write_revision(src, "two")
|
|
pack("install", str(src), "--dev")
|
|
two = store / active()
|
|
if two == one:
|
|
raise AssertionError("the update did not activate a new revision")
|
|
time.sleep(2)
|
|
if not shows(desktop, COLOURS["one"], 5) or shows(desktop, COLOURS["two"], 1):
|
|
raise AssertionError("the update changed what the running session shows")
|
|
if (one / "ui/index.html").read_text().find("200, 0, 0") < 0:
|
|
raise AssertionError("the running session's revision changed")
|
|
|
|
# 2. A failed update changes nothing.
|
|
write_revision(src, "bad", wasm=b"not a component")
|
|
pack("install", str(src), "--dev", ok=False)
|
|
if store / active() != two:
|
|
raise AssertionError("a failed update changed the active revision")
|
|
|
|
# 3. A new launch gets the update.
|
|
second = launch()
|
|
if not shows(desktop, COLOURS["two"]):
|
|
raise AssertionError("a launch after the update does not show revision two")
|
|
stop(second)
|
|
|
|
# 4. With the first session ended, the next update collects revision one.
|
|
if not one.is_dir():
|
|
raise AssertionError("revision one was removed while its session ran")
|
|
stop(first)
|
|
write_revision(src, "three")
|
|
pack("install", str(src), "--dev")
|
|
if one.exists():
|
|
raise AssertionError("revision one was kept after its session ended")
|
|
if not two.is_dir():
|
|
raise AssertionError("the previous revision was not kept for rollback")
|
|
pack("rollback", APP_ID)
|
|
if store / active() != two:
|
|
raise AssertionError("rollback did not make revision two active")
|
|
third = launch()
|
|
if not shows(desktop, COLOURS["two"]):
|
|
raise AssertionError("a launch after rollback does not show revision two")
|
|
|
|
# 5. Uninstall stops new launches, not the running session.
|
|
pack("uninstall", APP_ID)
|
|
appd.send({"type": "LAUNCH_APP", "app_id": APP_ID, "surface_id": 0})
|
|
refused = appd.wait_for(lambda m: m.get("type") in ("APP_READY", "ERROR"), 30)
|
|
if refused.get("code") != 404:
|
|
raise AssertionError(f"a launch after uninstall was not refused: {refused}")
|
|
if not two.is_dir() or not shows(desktop, COLOURS["two"], 5):
|
|
raise AssertionError("uninstall disturbed the running session")
|
|
stop(third)
|
|
pack("uninstall", APP_ID, ok=False)
|
|
if revisions.exists():
|
|
raise AssertionError(f"revisions left after uninstall: {list(revisions.iterdir())}")
|
|
|
|
# 6. A declared capability needs approval before the app launches.
|
|
write_revision(src, "one", capabilities='["sys:notifications"]')
|
|
pack("install", str(src), "--dev")
|
|
appd.send({"type": "LAUNCH_APP", "app_id": APP_ID, "surface_id": 0})
|
|
refused = appd.wait_for(lambda m: m.get("type") in ("APP_READY", "ERROR"), 30)
|
|
if refused.get("code") != 403 or "needs approval" not in refused.get("message", ""):
|
|
raise AssertionError(f"an unapproved capability launched: {refused}")
|
|
pack("approve", APP_ID)
|
|
stop(launch())
|
|
|
|
|
|
def main(argv=None):
|
|
parser = argparse.ArgumentParser(description=__doc__,
|
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
parser.add_argument("--compositor", type=Path, default=ROOT / "target/debug/weft-compositor")
|
|
parser.add_argument("--target", type=Path, default=ROOT / "target/debug",
|
|
help="directory with weft-appd, weft-pack, weft-runtime and weft-app-shell")
|
|
parser.add_argument("--output", type=Path, default=ROOT / "target/update-check")
|
|
args = parser.parse_args(argv)
|
|
|
|
missing = missing_tools() + [str(p) for p in (args.compositor, args.target / "weft-appd",
|
|
args.target / "weft-pack",
|
|
args.target / "weft-runtime",
|
|
args.target / "weft-app-shell")
|
|
if not p.is_file()]
|
|
if missing:
|
|
print("missing: " + ", ".join(missing), file=sys.stderr)
|
|
return 2
|
|
store = Path(tempfile.mkdtemp(prefix="weft-store-"))
|
|
home = Path(tempfile.mkdtemp(prefix="weft-home-"))
|
|
try:
|
|
with Desktop(args.compositor, args.output, outputs=["appd.log", "update.ppm"]) as desktop:
|
|
try:
|
|
run(args, desktop, store, home)
|
|
except AssertionError:
|
|
(args.output / "update.ppm").write_bytes(desktop.capture())
|
|
raise
|
|
except (AssertionError, SessionError, TimeoutError) as failure:
|
|
print(f"update check failed: {failure}", file=sys.stderr)
|
|
print(f"logs and capture in {args.output}", file=sys.stderr)
|
|
return 1
|
|
finally:
|
|
shutil.rmtree(store, ignore_errors=True)
|
|
shutil.rmtree(home, ignore_errors=True)
|
|
print("update check passed")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|