From fd5b6e8e63c2b3d1358f13cef9562e930d25cecb Mon Sep 17 00:00:00 2001 From: ELA CITY Date: Fri, 16 Oct 2026 17:12:11 +0000 Subject: [PATCH 1/4] perf(browser): reclaim completed guest control bridge workers Review package extracted from preserved candidate b0fa431d. The original eighteen commits remain on fix/runtime-performance-080. Validation of this recomposed head is recorded separately from historical candidate evidence. --- .../src/main.rs | 120 +++++++++++++++++- 1 file changed, 114 insertions(+), 6 deletions(-) diff --git a/elastos/tools/browser-vm-guest-control-bridge/src/main.rs b/elastos/tools/browser-vm-guest-control-bridge/src/main.rs index 56cd600ce..dc1a45e59 100644 --- a/elastos/tools/browser-vm-guest-control-bridge/src/main.rs +++ b/elastos/tools/browser-vm-guest-control-bridge/src/main.rs @@ -125,11 +125,13 @@ fn run_bridge(config: &BridgeConfig, stdout: &mut dyn Write) -> Result<(), Strin let mut accepted = 0_usize; let mut workers = Vec::new(); + let mut worker_error = None; loop { if config.max_sessions > 0 && accepted >= config.max_sessions { break; } let host_stream = listener.accept()?; + reap_finished_workers(&mut workers, &mut worker_error); accepted += 1; let session_id = accepted; eprintln!("browser VM guest control bridge accepted session {session_id}"); @@ -137,7 +139,7 @@ fn run_bridge(config: &BridgeConfig, stdout: &mut dyn Write) -> Result<(), Strin let buffer_bytes = config.buffer_bytes; let control_socket_ready_timeout_ms = config.control_socket_ready_timeout_ms; let control_request_timeout = Duration::from_millis(config.control_request_timeout_ms); - workers.push(thread::spawn(move || { + workers.push((session_id, thread::spawn(move || { let guest_stream = match connect_guest_control_socket( &guest_control_path, Duration::from_millis(control_socket_ready_timeout_ms), @@ -166,15 +168,51 @@ fn run_bridge(config: &BridgeConfig, stdout: &mut dyn Write) -> Result<(), Strin eprintln!("browser VM guest control bridge session {session_id} failed: {err}"); } Ok(()) - })); + }))); } for worker in workers { - worker - .join() - .map_err(|_| "browser VM guest control bridge worker panicked".to_string())??; + record_worker_result(worker, &mut worker_error); + } + match worker_error { + Some((_, error)) => Err(error), + None => Ok(()), + } +} + +type ControlWorker = (usize, thread::JoinHandle>); + +fn reap_finished_workers( + workers: &mut Vec, + first_error: &mut Option<(usize, String)>, +) { + let mut index = 0; + while index < workers.len() { + if workers[index].1.is_finished() { + record_worker_result(workers.swap_remove(index), first_error); + } else { + index += 1; + } + } +} + +fn record_worker_result( + (session_id, worker): ControlWorker, + first_error: &mut Option<(usize, String)>, +) { + let result = worker + .join() + .unwrap_or_else(|_| Err("browser VM guest control bridge worker panicked".to_string())); + if let Err(error) = result { + // Finite runs report the first failed accepted session even when later + // sessions finish first. A completed failure does not stop accepting. + if first_error + .as_ref() + .is_none_or(|(first_session, _)| session_id < *first_session) + { + *first_error = Some((session_id, error)); + } } - Ok(()) } fn proxy_http_control_request( @@ -707,6 +745,76 @@ fn accept_vsock(_listener_fd: RawFd) -> Result { mod tests { use super::*; + fn wait_until_finished(worker: &thread::JoinHandle>) { + let deadline = Instant::now() + Duration::from_secs(5); + while !worker.is_finished() { + assert!(Instant::now() < deadline, "worker did not finish"); + thread::yield_now(); + } + } + + #[test] + fn reaping_finished_workers_keeps_active_requests() { + let (release, blocked) = std::sync::mpsc::channel(); + let active = thread::spawn(move || { + blocked.recv().map_err(|error| error.to_string())?; + Ok(()) + }); + let finished = thread::spawn(|| Ok(())); + wait_until_finished(&finished); + let another_finished = thread::spawn(|| Ok(())); + wait_until_finished(&another_finished); + let (reported, observation) = std::sync::mpsc::channel(); + let reaper = thread::spawn(move || { + let mut workers = vec![(1, active), (2, finished), (3, another_finished)]; + let mut first_error = None; + reap_finished_workers(&mut workers, &mut first_error); + reported.send((workers, first_error)).unwrap(); + }); + + let result = observation.recv_timeout(Duration::from_secs(5)); + // Release and join every worker even if a regression made reaping wait + // for the active request to finish. + release.send(()).unwrap(); + reaper.join().unwrap(); + let (workers, mut first_error) = result.expect("reaping waited for an active request"); + let retained_sessions: Vec<_> = workers.iter().map(|(id, _)| *id).collect(); + for worker in workers { + record_worker_result(worker, &mut first_error); + } + assert_eq!(retained_sessions, vec![1]); + assert!(first_error.is_none()); + } + + #[test] + fn reaped_failures_keep_accept_order_until_final_join() { + let first = thread::spawn(|| Err("first accepted failure".to_string())); + let later = thread::spawn(|| Err("later accepted failure".to_string())); + wait_until_finished(&first); + wait_until_finished(&later); + let mut workers = vec![(2, later)]; + let mut first_error = None; + reap_finished_workers(&mut workers, &mut first_error); + let earlier_failure = first_error.clone(); + record_worker_result((1, first), &mut first_error); + assert_eq!(earlier_failure, Some((2, "later accepted failure".into()))); + assert_eq!(first_error, Some((1, "first accepted failure".into()))); + } + + #[test] + fn reaped_worker_panics_preserve_bridge_error() { + let panicked = thread::spawn(|| panic!("test worker panic")); + wait_until_finished(&panicked); + let mut workers = vec![(1, panicked)]; + let mut first_error = None; + reap_finished_workers(&mut workers, &mut first_error); + assert!(workers.is_empty()); + assert_eq!( + first_error, + Some((1, "browser VM guest control bridge worker panicked".into())) + ); + } + fn config(transport: HostListenConfig) -> BridgeConfig { BridgeConfig { schema: "elastos.browser.vm-guest-control-bridge.config/v1".to_string(), From 557cdd38b33c56566e79d529d49f61a2b5f00653 Mon Sep 17 00:00:00 2001 From: ELA CITY Date: Sat, 17 Oct 2026 05:42:08 +0000 Subject: [PATCH 2/4] fix(browser): preserve fail-fast bridge shutdown after worker reaping --- .../src/main.rs | 142 +++++++++++++++++- 1 file changed, 138 insertions(+), 4 deletions(-) diff --git a/elastos/tools/browser-vm-guest-control-bridge/src/main.rs b/elastos/tools/browser-vm-guest-control-bridge/src/main.rs index dc1a45e59..f9b302b7c 100644 --- a/elastos/tools/browser-vm-guest-control-bridge/src/main.rs +++ b/elastos/tools/browser-vm-guest-control-bridge/src/main.rs @@ -171,17 +171,34 @@ fn run_bridge(config: &BridgeConfig, stdout: &mut dyn Write) -> Result<(), Strin }))); } + finish_workers_in_accept_order(workers, worker_error) +} + +type ControlWorker = (usize, thread::JoinHandle>); + +fn finish_workers_in_accept_order( + mut workers: Vec, + mut first_error: Option<(usize, String)>, +) -> Result<(), String> { + // Reaping can reorder retained workers. Preserve the original finite-run + // behavior: resolve earlier sessions, then return the first error without + // waiting for later requests. + workers.sort_unstable_by_key(|(session_id, _)| *session_id); for worker in workers { - record_worker_result(worker, &mut worker_error); + if first_error + .as_ref() + .is_some_and(|(failed_session, _)| worker.0 > *failed_session) + { + break; + } + record_worker_result(worker, &mut first_error); } - match worker_error { + match first_error { Some((_, error)) => Err(error), None => Ok(()), } } -type ControlWorker = (usize, thread::JoinHandle>); - fn reap_finished_workers( workers: &mut Vec, first_error: &mut Option<(usize, String)>, @@ -801,6 +818,123 @@ mod tests { assert_eq!(first_error, Some((1, "first accepted failure".into()))); } + #[test] + fn finite_shutdown_does_not_wait_for_requests_after_the_first_failure() { + for reap_failure_first in [false, true] { + let (release, blocked) = std::sync::mpsc::channel(); + let (completed, completion) = std::sync::mpsc::channel(); + let active = thread::spawn(move || { + blocked.recv().map_err(|error| error.to_string())?; + completed.send(()).unwrap(); + Ok(()) + }); + let failed = thread::spawn(|| Err("first accepted failure".to_string())); + wait_until_finished(&failed); + // Reaping can leave a later active session ahead of an earlier one. + let mut workers = vec![(2, active), (1, failed)]; + let mut first_error = None; + if reap_failure_first { + reap_finished_workers(&mut workers, &mut first_error); + } + let (reported, observation) = std::sync::mpsc::channel(); + let finisher = thread::spawn(move || { + reported + .send(finish_workers_in_accept_order(workers, first_error)) + .unwrap(); + }); + + let result = observation.recv_timeout(Duration::from_secs(5)); + // Release the later worker before assertions, including when a + // regression caused finalization to wait for it. + release.send(()).unwrap(); + finisher.join().unwrap(); + completion.recv_timeout(Duration::from_secs(5)).unwrap(); + assert_eq!( + result.expect("finalization waited for a later active request"), + Err("first accepted failure".to_string()), + "reap_failure_first={reap_failure_first}" + ); + } + } + + #[test] + fn finite_shutdown_resolves_earlier_requests_before_a_reaped_failure() { + let (release_earlier, earlier_blocked) = std::sync::mpsc::channel(); + let (release_later, later_blocked) = std::sync::mpsc::channel(); + let (completed, completion) = std::sync::mpsc::channel(); + let earlier_completed = completed.clone(); + let earlier = thread::spawn(move || { + earlier_blocked.recv().map_err(|error| error.to_string())?; + earlier_completed.send(()).unwrap(); + Err("earlier accepted failure".to_string()) + }); + let later = thread::spawn(move || { + later_blocked.recv().map_err(|error| error.to_string())?; + completed.send(()).unwrap(); + Ok(()) + }); + let (reported, observation) = std::sync::mpsc::channel(); + let finisher = thread::spawn(move || { + reported + .send(finish_workers_in_accept_order( + vec![(3, later), (1, earlier)], + Some((2, "already reaped failure".to_string())), + )) + .unwrap(); + }); + + let premature = observation.recv_timeout(Duration::from_millis(20)); + let returned_before_earlier_finished = premature.is_ok(); + release_earlier.send(()).unwrap(); + let result = match premature { + Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { + observation.recv_timeout(Duration::from_secs(5)) + } + other => other, + }; + // Finalization must resolve session 1, but must not wait for session 3. + release_later.send(()).unwrap(); + finisher.join().unwrap(); + completion.recv_timeout(Duration::from_secs(5)).unwrap(); + completion.recv_timeout(Duration::from_secs(5)).unwrap(); + assert!(!returned_before_earlier_finished); + assert_eq!( + result.expect("finalization waited for a later active request"), + Err("earlier accepted failure".to_string()) + ); + } + + #[test] + fn finite_shutdown_joins_active_requests_when_none_has_failed() { + let (release, blocked) = std::sync::mpsc::channel(); + let (completed, completion) = std::sync::mpsc::channel(); + let active = thread::spawn(move || { + blocked.recv().map_err(|error| error.to_string())?; + completed.send(()).unwrap(); + Ok(()) + }); + let (reported, observation) = std::sync::mpsc::channel(); + let finisher = thread::spawn(move || { + reported + .send(finish_workers_in_accept_order(vec![(1, active)], None)) + .unwrap(); + }); + + let premature = observation.recv_timeout(Duration::from_millis(20)); + let returned_before_request_finished = premature.is_ok(); + release.send(()).unwrap(); + finisher.join().unwrap(); + completion.recv_timeout(Duration::from_secs(5)).unwrap(); + let result = match premature { + Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { + observation.recv_timeout(Duration::from_secs(5)) + } + other => other, + }; + assert!(!returned_before_request_finished); + assert_eq!(result.expect("finalization did not report success"), Ok(())); + } + #[test] fn reaped_worker_panics_preserve_bridge_error() { let panicked = thread::spawn(|| panic!("test worker panic")); From 1b9cbc3e4922ed9cd9580b0e4df1834e853ea1f9 Mon Sep 17 00:00:00 2001 From: SashaMIT Date: Sat, 17 Oct 2026 14:11:42 +0000 Subject: [PATCH 3/4] Exercise Browser bridge reclamation and add its CI checks Co-authored-by: Codex --- .github/workflows/ci.yml | 24 +++ .../src/main.rs | 160 +++++++++++++++++- scripts/ci-release-policy-test.py | 32 ++++ 3 files changed, 213 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c9a83ad7f..5981bd4cc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -278,6 +278,30 @@ jobs: retention-days: 1 compression-level: 0 + # This bridge is a separate Cargo workspace, outside the Runtime tests. + test-browser-guest-control-bridge: + name: test-browser-guest-control-bridge + runs-on: ubuntu-24.04 + timeout-minutes: 10 + needs: source-gate + defaults: + run: + working-directory: elastos/tools/browser-vm-guest-control-bridge + steps: + - uses: actions/checkout@fbc6f3992d24b796d5a048ff273f7fcc4a7b6c09 # v5 + with: + ref: ${{ github.event_name == 'workflow_dispatch' && inputs.ref || github.sha }} + persist-credentials: false + - uses: dtolnay/rust-toolchain@72504271e02fb719eb4eb3eaece3a8e3d06f57c0 # 1.91.0 + with: + components: rustfmt, clippy + - name: bridge formatting + run: cargo fmt -- --check + - name: bridge Clippy + run: cargo clippy --locked --all-targets -- -D warnings + - name: bridge tests + run: cargo test --locked + lint: name: lint runs-on: ubuntu-24.04 diff --git a/elastos/tools/browser-vm-guest-control-bridge/src/main.rs b/elastos/tools/browser-vm-guest-control-bridge/src/main.rs index f9b302b7c..54e84740a 100644 --- a/elastos/tools/browser-vm-guest-control-bridge/src/main.rs +++ b/elastos/tools/browser-vm-guest-control-bridge/src/main.rs @@ -46,6 +46,7 @@ struct BridgeConfig { replace_existing_socket: bool, #[serde(default = "default_buffer_bytes")] buffer_bytes: usize, + // Finite runs are for tests and smoke runs. The guest service uses zero. #[serde(default)] max_sessions: usize, #[serde(default = "default_control_socket_ready_timeout_ms")] @@ -169,6 +170,8 @@ fn run_bridge(config: &BridgeConfig, stdout: &mut dyn Write) -> Result<(), Strin } Ok(()) }))); + #[cfg(test)] + tests::observe_retained_workers(&workers); } finish_workers_in_accept_order(workers, worker_error) @@ -180,9 +183,9 @@ fn finish_workers_in_accept_order( mut workers: Vec, mut first_error: Option<(usize, String)>, ) -> Result<(), String> { - // Reaping can reorder retained workers. Preserve the original finite-run - // behavior: resolve earlier sessions, then return the first error without - // waiting for later requests. + // Only tests and smoke runs set max_sessions for this finite shutdown path. + // Reaping can reorder retained workers: resolve earlier sessions, then + // return the first error without waiting for later requests. workers.sort_unstable_by_key(|(session_id, _)| *session_id); for worker in workers { if first_error @@ -221,6 +224,7 @@ fn record_worker_result( .join() .unwrap_or_else(|_| Err("browser VM guest control bridge worker panicked".to_string())); if let Err(error) = result { + eprintln!("browser VM guest control bridge session {session_id} worker failed: {error}"); // Finite runs report the first failed accepted session even when later // sessions finish first. A completed failure does not stop accepting. if first_error @@ -762,6 +766,156 @@ fn accept_vsock(_listener_fd: RawFd) -> Result { mod tests { use super::*; + thread_local! { + static RETAINED_WORKER_COUNTS: std::cell::RefCell>> = const { + std::cell::RefCell::new(None) + }; + } + + pub(super) fn observe_retained_workers(workers: &[ControlWorker]) { + RETAINED_WORKER_COUNTS.with_borrow_mut(|counts| { + if let Some(counts) = counts { + counts.push(workers.len()); + // Make the next production accept see completed handles. This + // observes the actual vector and never removes a handle. + for (_, worker) in workers { + wait_until_finished(worker); + } + } + }); + } + + struct TestDirectory(PathBuf); + + impl TestDirectory { + fn new() -> Self { + let nonce = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos(); + let path = std::env::temp_dir().join(format!("eb-{}-{nonce:x}", std::process::id())); + fs::create_dir(&path).unwrap(); + Self(path) + } + } + + impl Drop for TestDirectory { + fn drop(&mut self) { + fs::remove_dir_all(&self.0).unwrap(); + } + } + + fn accept_test_session(listener: &UnixListener) -> UnixStream { + let deadline = Instant::now() + Duration::from_secs(5); + loop { + match listener.accept() { + Ok((stream, _)) => return stream, + Err(error) if error.kind() == io::ErrorKind::WouldBlock => { + assert!(Instant::now() < deadline, "guest session was not accepted"); + thread::yield_now(); + } + Err(error) => panic!("guest accept failed: {error}"), + } + } + } + + #[test] + fn run_bridge_reclaims_completed_handles_between_sessions() { + let directory = TestDirectory::new(); + let guest_path = directory.0.join("guest.sock"); + let host_path = directory.0.join("host.sock"); + let guest_listener = UnixListener::bind(&guest_path).unwrap(); + guest_listener.set_nonblocking(true).unwrap(); + let guest = thread::spawn(move || { + for _ in 0..3 { + let mut stream = DuplexStream::Unix(accept_test_session(&guest_listener)); + let request = read_one_http_request( + &mut stream, + 1024, + Instant::now() + Duration::from_secs(5), + ) + .unwrap(); + assert!(request.starts_with(b"GET /status HTTP/1.1\r\n")); + stream + .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok") + .unwrap(); + } + }); + let client_path = host_path.clone(); + let client = thread::spawn(move || { + for _ in 0..3 { + let mut stream = connect_guest_control_socket( + client_path.to_str().unwrap(), + Duration::from_secs(5), + ) + .unwrap(); + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + stream + .write_all(b"GET /status HTTP/1.1\r\nHost: browser-vm\r\n\r\n") + .unwrap(); + let mut response = String::new(); + stream.read_to_string(&mut response).unwrap(); + assert_eq!(response, "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok"); + } + }); + + let mut bridge = config(HostListenConfig::UnixListen { + path: host_path.to_str().unwrap().to_string(), + }); + bridge.guest_control_socket_path = guest_path.to_str().unwrap().to_string(); + bridge.max_sessions = 3; + bridge.control_socket_ready_timeout_ms = 5000; + bridge.control_request_timeout_ms = 5000; + RETAINED_WORKER_COUNTS.with_borrow_mut(|counts| *counts = Some(Vec::new())); + let result = run_bridge(&bridge, &mut Vec::new()); + let retained = RETAINED_WORKER_COUNTS + .with_borrow_mut(Option::take) + .unwrap(); + let client_result = client.join(); + let guest_result = guest.join(); + + assert_eq!(result, Ok(())); + client_result.unwrap(); + guest_result.unwrap(); + assert_eq!( + retained, + vec![1, 1, 1], + "completed handles survived the next accept" + ); + } + + #[test] + fn reaped_worker_failures_are_logged() { + for (test, messages) in [ + ( + "tests::reaped_failures_keep_accept_order_until_final_join", + vec![ + "session 2 worker failed: later accepted failure", + "session 1 worker failed: first accepted failure", + ], + ), + ( + "tests::reaped_worker_panics_preserve_bridge_error", + vec!["session 1 worker failed: browser VM guest control bridge worker panicked"], + ), + ] { + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", test, "--nocapture"]) + .output() + .unwrap(); + assert!(output.status.success()); + let stderr = String::from_utf8(output.stderr).unwrap(); + for message in messages { + assert!( + stderr.contains(message), + "missing worker log: {message}\n{stderr}" + ); + } + } + } + fn wait_until_finished(worker: &thread::JoinHandle>) { let deadline = Instant::now() + Duration::from_secs(5); while !worker.is_finished() { diff --git a/scripts/ci-release-policy-test.py b/scripts/ci-release-policy-test.py index 4d670a620..aac5b7801 100644 --- a/scripts/ci-release-policy-test.py +++ b/scripts/ci-release-policy-test.py @@ -1643,6 +1643,37 @@ def test_restored_inputs_are_verified_before_use(self): with self.subTest(mutation=name), self.assertRaises(AssertionError): validate_restores_are_verified(changed) + def test_guest_control_bridge_runs_its_own_workspace_checks(self): + def check(source): + workflow_jobs = jobs(source) + name = "test-browser-guest-control-bridge" + job = workflow_jobs[name] + self.assertEqual(field(job, "needs"), "source-gate") + self.assertEqual(field(job, "working-directory"), + "elastos/tools/browser-vm-guest-control-bridge") + job_steps = steps(name, workflow_jobs) + checkout, = [step for step in job_steps if "uses: actions/checkout@" in step] + self.assertEqual(field(checkout, "ref"), + "${{ github.event_name == 'workflow_dispatch' && inputs.ref || github.sha }}") + self.assertEqual(field(checkout, "persist-credentials"), "false") + toolchain, = [step for step in job_steps if "uses: dtolnay/rust-toolchain@" in step] + self.assertEqual(field(toolchain, "components"), "rustfmt, clippy") + commands = [field(step, "run") for step in job_steps + if re.search(r"(?m)^\s+run:", step)] + self.assertEqual(commands, ["cargo fmt -- --check", + "cargo clippy --locked --all-targets -- -D warnings", + "cargo test --locked"]) + self.assertNotRegex(job, r"(?m)^\s+(?:if|continue-on-error):") + + check(SOURCE) + for command in ("cargo fmt -- --check", + "cargo clippy --locked --all-targets -- -D warnings", + "cargo test --locked"): + changed = SOURCE.replace(f" run: {command}\n", " run: true\n", 1) + self.assertNotEqual(changed, SOURCE) + with self.subTest(removed=command), self.assertRaises(AssertionError): + check(changed) + def test_github_runners_and_check_names_stay_fixed(self): expected = { "source-gate": ("source-gate", "ubuntu-24.04"), @@ -1650,6 +1681,7 @@ def test_github_runners_and_check_names_stay_fixed(self): "engine-llama-amd64": ("engine-llama-amd64", "ubuntu-24.04"), "lint": ("lint", "ubuntu-24.04"), "test-elastos": ("test-elastos", "ubuntu-24.04"), + "test-browser-guest-control-bridge": ("test-browser-guest-control-bridge", "ubuntu-24.04"), "test-behaviour": ("test-behaviour", "ubuntu-24.04"), "test-capsules": ("test-capsules", "ubuntu-24.04"), "custody-harness-smoke": ("custody-harness-smoke", "ubuntu-24.04"), From 619c0961964aa2a5da938af5cba622349edb1382 Mon Sep 17 00:00:00 2001 From: SashaMIT Date: Sat, 17 Oct 2026 19:32:03 +0000 Subject: [PATCH 4/4] Use a platform-neutral app in Home link regression Use the installed System fixture for valid and invalid Home-link requests so the test exercises link authority on every host. Keep all assertions and production launch checks unchanged. Verified the exact Home-link test passes, reverting only the System token to Browser fails the intended 403-versus-200 assertion, and restoring the fixture passes again. Co-authored-by: Codex --- .../src/api/gateway_tests/home_system.rs | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/elastos/crates/elastos-server/src/api/gateway_tests/home_system.rs b/elastos/crates/elastos-server/src/api/gateway_tests/home_system.rs index a30bded9c..02d08fc68 100644 --- a/elastos/crates/elastos-server/src/api/gateway_tests/home_system.rs +++ b/elastos/crates/elastos-server/src/api/gateway_tests/home_system.rs @@ -11945,9 +11945,10 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { }) }; - let browser_token = launched(BROWSER_CAPSULE_ID); + // System is launchable on every host; Browser availability is platform-specific. + let system_token = launched(SYSTEM_CAPSULE_ID); for (app_token, app_id, app_title) in [ - (browser_token.clone(), BROWSER_CAPSULE_ID, "Browser"), + (system_token.clone(), SYSTEM_CAPSULE_ID, "System"), ( launched(HOME_CLI_CAPSULE_ID_FOR_TEST), "home-cli", @@ -11979,13 +11980,13 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { "foreign origin", "https://evil.example", home_token.clone(), - browser_token.clone(), + system_token.clone(), ), ( "an app frame calling directly", "null", home_token.clone(), - browser_token.clone(), + system_token.clone(), ), ( "app token from another Home session", @@ -11993,8 +11994,8 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { home_token.clone(), issue_home_projection_launch_token_with_context( dir.path(), - BROWSER_CAPSULE_ID, - BROWSER_CAPSULE_ID, + SYSTEM_CAPSULE_ID, + SYSTEM_CAPSULE_ID, &other_session, ) .unwrap(), @@ -12004,13 +12005,13 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { "http://localhost:61180", issue_home_launch_token_with_context(dir.path(), HOME_CAPSULE_ID, &other_session) .unwrap(), - browser_token.clone(), + system_token.clone(), ), ( "app token Home did not mint", "http://localhost:61180", home_token.clone(), - issue_home_launch_token_with_context(dir.path(), BROWSER_CAPSULE_ID, &context).unwrap(), + issue_home_launch_token_with_context(dir.path(), SYSTEM_CAPSULE_ID, &context).unwrap(), ), ( "Home GUI is not a link sender", @@ -12037,7 +12038,7 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { issue_home_projection_launch_token_with_context( dir.path(), "assistant", - BROWSER_CAPSULE_ID, + SYSTEM_CAPSULE_ID, &context, ) .unwrap(), @@ -12061,7 +12062,7 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { } let expired = - issue_expired_home_launch_token_with_context(dir.path(), BROWSER_CAPSULE_ID, &context) + issue_expired_home_launch_token_with_context(dir.path(), SYSTEM_CAPSULE_ID, &context) .unwrap(); let (status, body) = home_external_link_raw( &app, @@ -12088,7 +12089,7 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { &app, "http://localhost:61180", &home_token, - request(&browser_token, url), + request(&system_token, url), ) .await; assert_eq!(status, StatusCode::BAD_REQUEST, "{url:?}: {body}"); @@ -12099,13 +12100,13 @@ async fn home_external_link_names_the_launched_app_and_the_exact_address() { &home_token, json!({ "schema": "elastos.home.external-link.request/v2", - "app_token": browser_token, + "app_token": system_token, "url": "https://example.com/", }), ) .await; assert_eq!(status, StatusCode::BAD_REQUEST); - let mut extra = request(&browser_token, "https://example.com/"); + let mut extra = request(&system_token, "https://example.com/"); extra["app_id"] = json!("wallet"); let (status, _) = home_external_link_raw(&app, "http://localhost:61180", &home_token, extra).await;