macltok

public

Star0

Fork 0

Watch0

27 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `7aa42f589ee2`

tarball

atagen <boss@atagen.co>2026-09-27 01:42 UTC

7 files changed+348-29

harness: prove a real sync and the store lock from browser workers

Modified file: flake.nix+8 additions−3 deletions@@ -77,10 +77,11 @@
             rustc = toolchain;
           };
           # continuwuity refuses to start without /etc/resolv.conf, which the build sandbox lacks, or with
-          # stdenv's deliberately bogus SSL_CERT_FILE
+          # stdenv's deliberately bogus SSL_CERT_FILE. no exec, run.nu launches through a shell that exits at
+          # once and would trip --die-with-parent, so this shell stays as the parent run.nu kills
           sandboxedHomeserver = pkgs.writeShellScriptBin "conduwuit" ''
             export SSL_CERT_FILE=${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt
-            exec ${pkgs.lib.getExe pkgs.bubblewrap} --dev-bind / / --tmpfs /etc \
+            ${pkgs.lib.getExe pkgs.bubblewrap} --die-with-parent --dev-bind / / --tmpfs /etc \
               --ro-bind ${pkgs.writeText "resolv.conf" "nameserver 127.0.0.1\n"} /etc/resolv.conf \
               ${pkgs.lib.getExe' pkgs.matrix-continuwuity "conduwuit"} "$@"
           '';
@@ -93,7 +94,10 @@
             src = self;
             cargoLock.lockFile = ./Cargo.lock;
             preBuild = "export NIX_BUILD_CORES=2";
-            buildFeatures = [ "sqlite" ];
+            buildFeatures = [
+              "sqlite"
+              "mirror"
+            ];
             nativeBuildInputs = [ pkgs.pkg-config ];
             buildInputs = [ pkgs.sqlite ];
             SSL_CERT_FILE = "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";
@@ -105,6 +109,7 @@
             cargoLock.lockFile = ./Cargo.lock;
             buildPhase = ''
               runHook preBuild
+              cargo check --offline --frozen --lib --target wasm32-unknown-unknown -j 2
               cargo check --offline --frozen --lib \
                 --target wasm32-unknown-unknown --features ${storeFeature},mirror -j 2
               runHook postBuild

Modified file: harness/web/Cargo.lock+6 additions@@ -1722,6 +1722,7 @@ dependencies = [
  "getrandom 0.4.3",
  "http",
  "imbl",
+ "js-sys",
  "matrix-sdk",
  "matrix-sdk-crypto",
  "matrix-sdk-store-encryption",
@@ -1737,6 +1738,9 @@ dependencies = [
  "tracing",
  "url",
  "uuid",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
@@ -1744,6 +1748,8 @@ name = "macltok-web"
 version = "0.1.0"
 dependencies = [
  "futures-channel",
+ "futures-util",
+ "gloo-timers",
  "js-sys",
  "macltok",
  "wasm-bindgen",

Modified file: harness/web/Cargo.toml+16 additions−2 deletions@@ -19,11 +19,25 @@ macltok = { path = "../.." }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 futures-channel = "0.3"
+futures-util = { version = "0.3", default-features = false }
+gloo-timers = { version = "0.3", features = ["futures"] }
+js-sys = "0.3"
 
 [dev-dependencies]
-js-sys = "0.3"
 wasm-bindgen-test = "0.3"
-web-sys = { version = "0.3", features = ["DedicatedWorkerGlobalScope"] }
+web-sys = { version = "0.3", features = [
+    "Blob",
+    "BlobPropertyBag",
+    "DedicatedWorkerGlobalScope",
+    "SharedWorkerGlobalScope",
+    "Url",
+    "Worker",
+] }
+
+# with debuginfo the test wasm is 580 MB and wasm-bindgen-test-runner peaked at 11 GB before the
+# OOM killer took it
+[profile.dev]
+debug = false
 
 [profile.release]
 opt-level = "z"

Modified file: harness/web/run.nu+9 additions−2 deletions@@ -5,6 +5,8 @@ const crate = path self .
 const root = path self ../..
 const username = "harness"
 const password = "harness-password"
+const room_name = "harness"
+const seeded = "seeded by run.nu"
 
 # the shared build wrapper sets CARGO_TARGET_DIR, the nix sandbox does not
 def target [] { $env.CARGO_TARGET_DIR? | default ($root | path join target) }
@@ -50,7 +52,10 @@ def login [url: string] {
 
 def seed [url: string] {
     let auth = [Authorization $'Bearer ((login $url).access_token)']
-    http post --headers $auth --content-type application/json $'($url)/_matrix/client/v3/createRoom' { name: "harness" } | ignore
+    let room = http post --headers $auth --content-type application/json $'($url)/_matrix/client/v3/createRoom' { name: $room_name }
+    let room_id = $room.room_id | url encode --all
+    let message = { msgtype: "m.text", body: $seeded }
+    http put --headers $auth --content-type application/json $'($url)/_matrix/client/v3/rooms/($room_id)/send/m.room.message/seed' $message | ignore
 }
 
 def stop [pid: string] {
@@ -70,10 +75,12 @@ def main [] {
             MACLTOK_HOMESERVER: $server.url
             MACLTOK_USERNAME: $username
             MACLTOK_PASSWORD: $password
+            MACLTOK_ROOM_NAME: $room_name
+            MACLTOK_SEEDED: $seeded
             GECKODRIVER: (which geckodriver | get 0.path)
             WASM_BINDGEN_TEST_TIMEOUT: "180"
         } {
-            ^cargo test --target wasm32-unknown-unknown --test worker
+            ^cargo test --target wasm32-unknown-unknown --test worker --test shared_worker
         }
         null
     } catch {|error| $error }

Modified file: harness/web/src/lib.rs+181 additions−19 deletions@@ -1,47 +1,209 @@
 //! a browser-side slice of macltok, login through to a live sync, exported for
-//! wasm-bindgen so both the worker test and the size measurement reach the same code
+//! wasm-bindgen so both the worker tests and the size measurement reach the same code
 
-use futures_channel::oneshot;
+use std::{pin::pin, sync::Arc};
+
+use futures_channel::{mpsc, oneshot};
+use futures_util::{
+    StreamExt,
+    future::{Either, select},
+};
+use gloo_timers::future::TimeoutFuture;
 use macltok::{
-    ConnectionState, EncryptedSessionStore, EngineConfig, Event, PasswordLogin, Session, StoreConfig,
+    ClientHandle, EncryptedSessionStore, EngineConfig, Error, Event, EventStream, MessageContent,
+    PasswordLogin, RoomMembership, SendState, Session, StoreConfig, TimelineContent, TimelineDiff,
+    TimelineId, TimelineItem, imbl::Vector,
 };
 use wasm_bindgen::prelude::*;
 
+const PHASE_TIMEOUT_MS: f64 = 30_000.0;
+
+/// logs in, then proves a real sliding sync by finding the seeded room, reading the
+/// seeded message out of its timeline, and seeing a message of its own come back from
+/// the server
 #[wasm_bindgen]
 pub async fn smoke(
     homeserver: String,
     username: String,
     password: String,
     store_name: String,
+    room_name: String,
+    seeded: String,
 ) -> Result<(), JsError> {
-    let sessions = EncryptedSessionStore::indexeddb(
-        StoreConfig::indexeddb(store_name, "macltok-web").with_lock_holder("macltok-web-worker"),
-    );
+    let sessions = Arc::new(EncryptedSessionStore::indexeddb(
+        StoreConfig::indexeddb(store_name.clone(), "macltok-web"),
+    ));
     let login = PasswordLogin::new(homeserver, username, password);
-    let session = Session::login_password(login, &sessions).await?;
-    let (engine, handle, mut events) = session.build(EngineConfig::default()).await?;
+    let session = Session::login_password(login, sessions).await?;
+    let (engine, handle, events) = session.build(EngineConfig::default()).await?;
+    let (panicked, panics) = mpsc::unbounded();
+    macltok::on_panic(move |message| {
+        let _ = panicked.unbounded_send(message.to_owned());
+    });
+    let mut events = Watched { events, panics };
     let (done, running) = oneshot::channel();
     wasm_bindgen_futures::spawn_local(async move {
         let _ = done.send(engine.run().await);
     });
 
-    let mut online = false;
-    let mut rooms = false;
-    while !(online && rooms) {
-        match events.recv().await {
-            Some(Event::ConnectionChanged(ConnectionState::Online)) => online = true,
-            Some(Event::RoomsChanged) => rooms = true,
-            Some(Event::Stopped) | None => {
-                return Err(JsError::new("engine stopped before it came online"));
-            }
-            Some(_) => {}
+    let mut phase = Phase::new("the seeded room to sync");
+    let (_never, mut idle) = oneshot::channel();
+    let room_id = loop {
+        let rooms = handle.rooms().await;
+        if let Some(room) = rooms
+            .into_iter()
+            .find(|room| room.membership == RoomMembership::Joined && room.name == room_name)
+        {
+            break room.room_id;
         }
+        while !matches!(
+            phase.next(&mut events, &mut idle).await?,
+            Event::RoomsChanged
+        ) {}
+    };
+    let timeline_id = TimelineId::from(room_id.clone());
+
+    let mut phase = Phase::new("the seeded message in the opened timeline");
+    let mut opening = command(
+        &handle,
+        |handle| async move { handle.open_room(room_id).await },
+    );
+    let mut items = None;
+    while !contains(&items, &seeded, false) {
+        let event = phase.next(&mut events, &mut opening).await?;
+        track(&timeline_id, event, &mut items)?;
+    }
+
+    let sent = format!("{seeded}, answered from {store_name}");
+    let mut phase = Phase::new("the sent message to come back from the server");
+    let content = MessageContent::text(sent.clone());
+    let target = timeline_id.clone();
+    let mut sending = command(&handle, |handle| async move {
+        handle.send_message(target, content).await
+    });
+    while !contains(&items, &sent, true) {
+        let event = phase.next(&mut events, &mut sending).await?;
+        track(&timeline_id, event, &mut items)?;
     }
 
     handle.shutdown().await?;
-    while events.recv().await.is_some() {}
+    while events.events.recv().await.is_some() {}
     running
         .await
         .map_err(|_| JsError::new("engine task vanished"))??;
     Ok(())
 }
+
+/// answers only arrive while the event stream is drained, so commands run beside it
+fn command<F>(
+    handle: &ClientHandle,
+    run: impl FnOnce(ClientHandle) -> F,
+) -> oneshot::Receiver<Result<(), Error>>
+where
+    F: Future<Output = Result<(), Error>> + 'static,
+{
+    let (answer, answered) = oneshot::channel();
+    let pending = run(handle.clone());
+    wasm_bindgen_futures::spawn_local(async move {
+        let _ = answer.send(pending.await);
+    });
+    answered
+}
+
+/// a panicking engine task goes silent rather than stopping, and a phase would otherwise wait
+/// out its whole timeout
+struct Watched {
+    events: EventStream,
+    panics: mpsc::UnboundedReceiver<String>,
+}
+
+struct Phase {
+    what: &'static str,
+    deadline: f64,
+}
+
+impl Phase {
+    fn new(what: &'static str) -> Self {
+        Self {
+            what,
+            deadline: js_sys::Date::now() + PHASE_TIMEOUT_MS,
+        }
+    }
+
+    async fn next(
+        &mut self,
+        watched: &mut Watched,
+        pending: &mut oneshot::Receiver<Result<(), Error>>,
+    ) -> Result<Event, JsError> {
+        let left = (self.deadline - js_sys::Date::now()).max(0.0);
+        let timeout = TimeoutFuture::new(left as u32);
+        let panicked = watched.panics.next();
+        let outcome = match select(pin!(watched.events.recv()), select(timeout, panicked)).await {
+            Either::Left((event, _)) => Some(event),
+            Either::Right((Either::Left(_), _)) => None,
+            Either::Right((Either::Right((message, _)), _)) => {
+                return Err(JsError::new(&format!(
+                    "panicked while waiting for {}, {}",
+                    self.what,
+                    message.unwrap_or_default()
+                )));
+            }
+        };
+        if let Ok(Some(Err(error))) = pending.try_recv() {
+            return Err(JsError::new(&format!("{} failed, {error}", self.what)));
+        }
+        match outcome {
+            Some(Some(Event::Stopped) | None) => Err(JsError::new(&format!(
+                "engine stopped while waiting for {}",
+                self.what
+            ))),
+            Some(Some(Event::SessionSaveFailed { message })) => Err(JsError::new(&format!(
+                "saving the session failed while waiting for {}, {message}",
+                self.what
+            ))),
+            Some(Some(event)) => Ok(event),
+            None => Err(JsError::new(&format!(
+                "timed out after {}s waiting for {}",
+                PHASE_TIMEOUT_MS / 1000.0,
+                self.what
+            ))),
+        }
+    }
+}
+
+fn track(
+    timeline_id: &TimelineId,
+    event: Event,
+    items: &mut Option<Vector<TimelineItem>>,
+) -> Result<(), JsError> {
+    match event {
+        Event::TimelineReset {
+            timeline_id: id,
+            items: snapshot,
+        } if &id == timeline_id => *items = Some(snapshot),
+        Event::TimelineChanged {
+            timeline_id: id,
+            diffs,
+        } if &id == timeline_id => {
+            if let Some(items) = items {
+                TimelineDiff::try_apply_all(diffs, items)
+                    .map_err(|error| JsError::new(&format!("timeline diff misfit, {error:?}")))?;
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+fn contains(items: &Option<Vector<TimelineItem>>, body: &str, remote_echo: bool) -> bool {
+    items.iter().flatten().any(|item| {
+        let TimelineItem::Event(event) = item else {
+            return false;
+        };
+        let TimelineContent::Message(message) = &event.content else {
+            return false;
+        };
+        message.body == body
+            && (!remote_echo || (event.event_id.is_some() && event.send_state == SendState::Sent))
+    })
+}

Added file: harness/web/tests/shared_worker.rs+21 additions@@ -0,0 +1,21 @@
+//! needs a live homeserver, run.nu starts and seeds one and bakes its details in at build time
+
+use wasm_bindgen::JsCast;
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_shared_worker);
+
+#[wasm_bindgen_test]
+async fn logs_in_and_syncs() {
+    assert!(js_sys::global().is_instance_of::<web_sys::SharedWorkerGlobalScope>());
+    macltok_web::smoke(
+        env!("MACLTOK_HOMESERVER").into(),
+        env!("MACLTOK_USERNAME").into(),
+        env!("MACLTOK_PASSWORD").into(),
+        "macltok-shared".into(),
+        env!("MACLTOK_ROOM_NAME").into(),
+        env!("MACLTOK_SEEDED").into(),
+    )
+    .await
+    .unwrap_or_else(|error| panic!("{:?}", wasm_bindgen::JsValue::from(error)));
+}

Modified file: harness/web/tests/worker.rs+107 additions−3 deletions@@ -1,6 +1,14 @@
-//! needs a live homeserver, run.nu starts one and bakes its credentials in at build time
+//! needs a live homeserver, run.nu starts and seeds one and bakes its details in at build time
 
-use wasm_bindgen::JsCast;
+use std::sync::Arc;
+
+use js_sys::{Array, Promise, Reflect};
+use macltok::{
+    AccountError, EncryptedSessionStore, EngineConfig, PasswordLogin, Restore, Session,
+    SessionStore, StoreConfig,
+};
+use wasm_bindgen::{JsCast, JsValue};
+use wasm_bindgen_futures::JsFuture;
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_dedicated_worker);
@@ -12,8 +20,104 @@ async fn logs_in_and_syncs() {
         env!("MACLTOK_HOMESERVER").into(),
         env!("MACLTOK_USERNAME").into(),
         env!("MACLTOK_PASSWORD").into(),
-        "macltok-web".into(),
+        "macltok-dedicated".into(),
+        env!("MACLTOK_ROOM_NAME").into(),
+        env!("MACLTOK_SEEDED").into(),
     )
     .await
     .unwrap_or_else(|error| panic!("{:?}", wasm_bindgen::JsValue::from(error)));
 }
+
+#[wasm_bindgen_test]
+async fn one_engine_per_store() {
+    assert_secure_context();
+    let first = Session::login_password(login(), sessions("macltok-lock"))
+        .await
+        .expect("first login");
+    assert_in_use(Session::login_password(login(), sessions("macltok-lock")).await);
+    let (engine, handle, events) = first.build(EngineConfig::default()).await.unwrap();
+    assert_in_use(Session::restore(sessions("macltok-lock")).await);
+    drop(engine);
+    drop(events);
+    assert_in_use(Session::restore(sessions("macltok-lock")).await);
+    drop(handle);
+    let Some(Restore::Resumed(second)) = Session::restore(sessions("macltok-lock"))
+        .await
+        .expect("restore once the first engine is gone")
+    else {
+        panic!("the saved login did not resume");
+    };
+    second.build(EngineConfig::default()).await.unwrap();
+}
+
+/// the holder is plain js in a nested worker, since a second wasm instance would need
+/// the test bundle's own glue
+#[wasm_bindgen_test]
+async fn a_terminated_worker_frees_the_store() {
+    assert_secure_context();
+    let holder = r#"navigator.locks.request("macltok:macltok-orphan", () => {
+        postMessage("held");
+        return new Promise(() => {});
+    });"#;
+    let options = web_sys::BlobPropertyBag::new();
+    options.set_type("text/javascript");
+    let blob = web_sys::Blob::new_with_str_sequence_and_options(
+        &Array::of1(&JsValue::from_str(holder)),
+        &options,
+    )
+    .unwrap();
+    let url = web_sys::Url::create_object_url_with_blob(&blob).unwrap();
+    let worker = web_sys::Worker::new(&url).unwrap();
+    let held = Promise::new(&mut |resolve, _| worker.set_onmessage(Some(&resolve)));
+    JsFuture::from(held).await.unwrap();
+
+    assert_in_use(Session::login_password(login(), sessions("macltok-orphan")).await);
+    worker.terminate();
+    let terminated = js_sys::Date::now();
+    let session = loop {
+        match Session::login_password(login(), sessions("macltok-orphan")).await {
+            Err(AccountError::StoreInUse) if js_sys::Date::now() - terminated < 5_000.0 => {
+                gloo_timers::future::TimeoutFuture::new(50).await;
+            }
+            outcome => break outcome.expect("login once the holder is terminated"),
+        }
+    };
+    console_log!(
+        "the lock came free {}ms after terminate",
+        js_sys::Date::now() - terminated
+    );
+    drop(session);
+}
+
+fn login() -> PasswordLogin {
+    PasswordLogin::new(
+        env!("MACLTOK_HOMESERVER"),
+        env!("MACLTOK_USERNAME"),
+        env!("MACLTOK_PASSWORD"),
+    )
+}
+
+fn sessions(store: &str) -> Arc<dyn SessionStore> {
+    Arc::new(EncryptedSessionStore::indexeddb(StoreConfig::indexeddb(
+        store,
+        "macltok-web",
+    )))
+}
+
+fn assert_secure_context() {
+    let secure = Reflect::get(&js_sys::global(), &"isSecureContext".into()).unwrap();
+    assert_eq!(
+        secure,
+        JsValue::TRUE,
+        "the runner's origin is not a secure context, so it has no Web Locks"
+    );
+}
+
+#[track_caller]
+fn assert_in_use<T>(outcome: Result<T, AccountError>) {
+    match outcome {
+        Err(AccountError::StoreInUse) => {}
+        Err(error) => panic!("expected StoreInUse, got {error:?}"),
+        Ok(_) => panic!("expected StoreInUse, got a second session"),
+    }
+}

macltok

Commit 7aa42f589ee2

Commit `7aa42f589ee2`