diff --git a/capsules/browser-engine-adapter/src/main.rs b/capsules/browser-engine-adapter/src/main.rs index 026ff4d2d..4dcce0bd9 100644 --- a/capsules/browser-engine-adapter/src/main.rs +++ b/capsules/browser-engine-adapter/src/main.rs @@ -155,6 +155,8 @@ enum Response { adapter: Option, #[serde(skip_serializing_if = "Option::is_none")] launch_settlement_result: Option, + #[serde(skip_serializing_if = "Option::is_none")] + refusal: Option, }, } @@ -173,6 +175,7 @@ impl Response { message: message.into(), adapter: None, launch_settlement_result: None, + refusal: None, } } @@ -182,6 +185,7 @@ impl Response { message: error.message, adapter: Some(adapter.id.clone()), launch_settlement_result: error.launch_settlement_result, + refusal: error.refusal, } } } diff --git a/capsules/browser-engine-adapter/src/supervisor.rs b/capsules/browser-engine-adapter/src/supervisor.rs index e140d3433..c7ca67273 100644 --- a/capsules/browser-engine-adapter/src/supervisor.rs +++ b/capsules/browser-engine-adapter/src/supervisor.rs @@ -25,6 +25,7 @@ pub(super) struct SupervisorLaunchError { pub(super) code: String, pub(super) message: String, pub(super) launch_settlement_result: Option, + pub(super) refusal: Option, } impl SupervisorLaunchError { @@ -33,6 +34,7 @@ impl SupervisorLaunchError { code: "engine_process_unavailable".to_string(), message: message.into(), launch_settlement_result: None, + refusal: None, } } } @@ -45,6 +47,8 @@ struct TypedSupervisorLaunchError { message: String, #[serde(default)] launch_settlement_result: Option, + #[serde(default)] + refusal: Option, } fn supervisor_launch_error( @@ -67,6 +71,10 @@ fn supervisor_launch_error( code: error.code, message: error.message, launch_settlement_result, + refusal: error + .refusal + .as_ref() + .and_then(elastos_common::browser_protocol::BrowserLaunchRefusal::from_value), }; } SupervisorLaunchError::process(format!( @@ -846,3 +854,39 @@ mod private_request_tests { let _ = fs::remove_file(marker); } } + +#[cfg(test)] +mod refusal_tests { + use super::*; + + #[test] + fn supervisor_space_refusal_reaches_the_adapter_response() { + use std::os::unix::process::ExitStatusExt; + let adapter: AdapterConfig = serde_json::from_value(json!({ + "id": "browser-vm-product", "kind": "chromium_microvm", + "display_modes": ["webrtc_remote_display"], + })) + .unwrap(); + for (code, available, valid) in [ + ("insufficient_free_space", json!(8589934591_u64), true), + ("unknown", json!(8589934591_u64), false), + ("insufficient_free_space", json!(-1), false), + ] { + let refusal = json!({"code": code, "required_bytes": 8589934592_u64, "available_bytes": available}); + let stderr = json!({ + "schema": "elastos.browser.engine.launch-error/v1", "code": "launch_refused", + "message": "private engine text", "refusal": refusal, + }) + .to_string(); + let error = + supervisor_launch_error(std::process::ExitStatus::from_raw(42 << 8), &stderr, None); + let response = + serde_json::to_value(Response::supervisor_error(&adapter, error)).unwrap(); + if valid { + assert_eq!(response["refusal"], refusal); + } else { + assert!(response.get("refusal").is_none()); + } + } + } +} diff --git a/capsules/browser/browser/browser-status.js b/capsules/browser/browser/browser-status.js index 7e705b545..49b4dd78c 100644 --- a/capsules/browser/browser/browser-status.js +++ b/capsules/browser/browser/browser-status.js @@ -65,6 +65,20 @@ export function friendlyOpenError(error) { return "Browser session expired. Reopening from Home..."; } const outcome = runtimeOpenOutcome(error); + const refusal = error?.payload?.refusal; + if ( + ["terminal_pre_effect_failure", "terminal_post_effect_cleanup"].includes(outcome?.state) && + outcome.effects.page_acquired === false && outcome.effects.vm_acquired === false && + outcome.effects.stream_acquired === false && + refusal && Object.keys(refusal).length === 3 && + refusal.code === "insufficient_free_space" && + Number.isSafeInteger(refusal.required_bytes) && Number.isSafeInteger(refusal.available_bytes) && + refusal.available_bytes >= 0 && refusal.available_bytes < refusal.required_bytes + ) { + const required = (Math.ceil(refusal.required_bytes / 100_000_000) / 10).toFixed(1); + const available = (Math.floor(refusal.available_bytes / 100_000_000) / 10).toFixed(1); + return `Browser needs ${required} GB free on this computer to open; ${available} GB are free. Free some space, then open Browser again.`; + } if (outcome?.state === "terminal_pre_effect_failure" && error?.payload?.stage === "viewer_compatibility") { return error.payload.code === "unsupported_viewer_display_mode" ? "This Browser view needs a streamed display. Open Browser from Home with its default display." diff --git a/capsules/browser/browser/browser-status.test.mjs b/capsules/browser/browser/browser-status.test.mjs index 6bb8d1eda..c458b35bd 100644 --- a/capsules/browser/browser/browser-status.test.mjs +++ b/capsules/browser/browser/browser-status.test.mjs @@ -51,6 +51,42 @@ function openError(state, effects) { return error; } +test("space refusal reports required and available decimal GB after safe cleanup", () => { + for (const state of ["terminal_pre_effect_failure", "terminal_post_effect_cleanup"]) { + const error = openError(state); + error.payload.refusal = { + code: "insufficient_free_space", required_bytes: 8589934592, available_bytes: 8589934591, + }; + error.payload.message = "private engine error text"; + assert.equal(friendlyOpenError(error), "Browser needs 8.6 GB free on this computer to open; 8.5 GB are free. Free some space, then open Browser again."); + } +}); + +test("invalid, unknown and pending refusals keep the generic failure", () => { + const error = openError("terminal_post_effect_cleanup"); + const generic = friendlyOpenError(error); + error.message = "Browser needs 8.6 GB free on this computer to open; 8.5 GB are free. Free some space, then open Browser again."; + assert.equal(friendlyOpenError(error), generic, "message text grants no refusal code"); + for (const refusal of [ + undefined, + { code: "unknown", required_bytes: 20, available_bytes: 10 }, + { code: "insufficient_free_space", required_bytes: "20", available_bytes: 10 }, + { code: "insufficient_free_space", required_bytes: 10, available_bytes: 20 }, + { code: "insufficient_free_space", required_bytes: 20, available_bytes: -1 }, + { code: "insufficient_free_space", required_bytes: 2 ** 53, available_bytes: 10 }, + { code: "insufficient_free_space", required_bytes: 20, available_bytes: 10, message: "private" }, + ]) { + error.payload.refusal = refusal; + assert.equal(friendlyOpenError(error), generic); + } + error.payload.refusal = { code: "insufficient_free_space", required_bytes: 20, available_bytes: 10 }; + error.payload.outcome.state = "cleanup_pending"; + assert.match(friendlyOpenError(error), /finishing cleanup/); + error.payload.outcome.state = "terminal_post_effect_cleanup"; + error.payload.outcome.effects.vm_acquired = true; + assert.equal(friendlyOpenError(error), generic); +}); + test("pre-effect open failure never claims a missing terminal close", () => { const error = openError("terminal_pre_effect_failure"); diff --git a/elastos/CHANGELOG.md b/elastos/CHANGELOG.md index 789809466..d77154792 100644 --- a/elastos/CHANGELOG.md +++ b/elastos/CHANGELOG.md @@ -12,6 +12,7 @@ release's Added, Changed, Fixed, Removed and Security bullets before you update; ### Fixed +- When Browser cannot open because the computer is short of space, it says how much space it needs. - On a Jetson, Browser uses more of the processor, so scrolling is about twice as smooth. - On Linux, Browser is turned on when you choose it, not during install. - Open apps, including Chat, stay connected while Home runs, and reconnect by themselves after a network drop or a restart. diff --git a/elastos/crates/elastos-common/src/browser_protocol.rs b/elastos/crates/elastos-common/src/browser_protocol.rs index be1a16ffc..0a3a54425 100644 --- a/elastos/crates/elastos-common/src/browser_protocol.rs +++ b/elastos/crates/elastos-common/src/browser_protocol.rs @@ -18,6 +18,32 @@ pub const BROWSER_ENGINE_CLEANUP_BINDING_SCHEMA: &str = "elastos.browser.engine- pub const BROWSER_ENGINE_CLEANUP_RESULT_SCHEMA: &str = "elastos.browser.engine-cleanup-result/v2"; pub const MAX_BROWSER_ENGINE_ADAPTERS: usize = 64; +/// Person-actionable launch refusals. Runtime exposes only this closed set; +/// engine diagnostics stay with the Engine. +#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)] +#[serde(tag = "code", rename_all = "snake_case", deny_unknown_fields)] +pub enum BrowserLaunchRefusal { + InsufficientFreeSpace { + required_bytes: u64, + available_bytes: u64, + }, +} + +impl BrowserLaunchRefusal { + pub fn from_value(value: &Value) -> Option { + let refusal: Self = serde_json::from_value(value.clone()).ok()?; + match refusal { + Self::InsufficientFreeSpace { + required_bytes, + available_bytes, + } if available_bytes < required_bytes && required_bytes < (1_u64 << 53) => { + Some(refusal) + } + _ => None, + } + } +} + #[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)] #[serde(rename_all = "snake_case")] pub enum BrowserDisplayMode { diff --git a/elastos/crates/elastos-common/src/browser_protocol/tests.rs b/elastos/crates/elastos-common/src/browser_protocol/tests.rs index 6c94b8c35..d90a00a55 100644 --- a/elastos/crates/elastos-common/src/browser_protocol/tests.rs +++ b/elastos/crates/elastos-common/src/browser_protocol/tests.rs @@ -261,3 +261,24 @@ fn readiness_accepts_only_the_declared_state_and_reason_fields() { assert!(serde_json::from_value::(value).is_err()); } } + +#[test] +fn launch_refusal_accepts_only_known_codes_and_safe_byte_counts() { + let good = json!({"code": "insufficient_free_space", "required_bytes": 8589934592_u64, "available_bytes": 8589934591_u64}); + assert_eq!( + serde_json::to_value(BrowserLaunchRefusal::from_value(&good).unwrap()).unwrap(), + good + ); + for (key, value) in [ + ("code", json!("unknown")), + ("required_bytes", json!("8589934592")), + ("available_bytes", json!(-1)), + ("available_bytes", json!(8589934592_u64)), + ("required_bytes", json!(1_u64 << 53)), + ("message", json!("private")), + ] { + let mut bad = good.clone(); + bad[key] = value; + assert!(BrowserLaunchRefusal::from_value(&bad).is_none()); + } +} diff --git a/elastos/crates/elastos-server/src/api/gateway.rs b/elastos/crates/elastos-server/src/api/gateway.rs index c8351237f..ce529a2ed 100644 --- a/elastos/crates/elastos-server/src/api/gateway.rs +++ b/elastos/crates/elastos-server/src/api/gateway.rs @@ -1388,6 +1388,10 @@ fn gateway_provider_error_response(scheme: &str, err: anyhow::Error) -> Response } fn gateway_provider_error_tuple(scheme: &str, err: anyhow::Error) -> (StatusCode, String) { + (gateway_provider_error_status(scheme, &err), err.to_string()) +} + +fn gateway_provider_error_status(scheme: &str, err: &anyhow::Error) -> StatusCode { let text = err.to_string(); let unavailable = format!("{scheme} provider unavailable"); let forbidden = text.contains("home launch token") @@ -1397,7 +1401,7 @@ fn gateway_provider_error_tuple(scheme: &str, err: anyhow::Error) -> (StatusCode || text.contains("private host blocked") || text.contains("private IP blocked") || text.contains("private network"); - let status = if forbidden { + if forbidden { StatusCode::FORBIDDEN } else if text.contains(&unavailable) { StatusCode::SERVICE_UNAVAILABLE @@ -1412,8 +1416,7 @@ fn gateway_provider_error_tuple(scheme: &str, err: anyhow::Error) -> (StatusCode StatusCode::BAD_REQUEST } else { StatusCode::INTERNAL_SERVER_ERROR - }; - (status, text) + } } fn inbox_error_response(err: anyhow::Error) -> Response { diff --git a/elastos/crates/elastos-server/src/api/gateway_browser.rs b/elastos/crates/elastos-server/src/api/gateway_browser.rs index eb684bd1b..6ee14dcde 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser.rs @@ -86,8 +86,16 @@ pub(super) struct BrowserProviderResourceCall { pub(super) request: serde_json::Value, } +// Diagnostics stay private until the failure is consumed by status_value. +// Public messages accept only static copy or closed, typed public errors. #[derive(Debug)] pub(in crate::api::gateway) struct BrowserOpenFailure { + diagnostic: anyhow::Error, + public: BrowserOpenPublicFailure, +} + +#[derive(Debug)] +struct BrowserOpenPublicFailure { status: StatusCode, body: BrowserOpenFailureBody, outcome: serde_json::Value, @@ -95,8 +103,52 @@ pub(in crate::api::gateway) struct BrowserOpenFailure { #[derive(Debug)] enum BrowserOpenFailureBody { - Text(String), - Json(serde_json::Value), + Message { + code: BrowserOpenFailureCode, + message: &'static str, + }, + Compatibility(BrowserCompatibilityError), + Refused(elastos_common::browser_protocol::BrowserLaunchRefusal), + ExitPolicy { + host: String, + }, + HostSetupRequired { + message: &'static str, + }, +} + +#[derive(Debug, Clone, Copy)] +enum BrowserOpenFailureCode { + RequestRejected, + RuntimeError, + ProviderError, + ProfileTransferRequired, + BrowserCapacityUnavailable, + ResourcesInUse, + ProfileRecoveryRequired, +} + +impl BrowserOpenFailureCode { + fn as_str(self) -> &'static str { + match self { + Self::RequestRejected => "request_rejected", + Self::RuntimeError => "runtime_error", + Self::ProviderError => "provider_error", + Self::ProfileTransferRequired => "profile_transfer_required", + Self::BrowserCapacityUnavailable => "browser_capacity_unavailable", + Self::ResourcesInUse => "resources_in_use", + Self::ProfileRecoveryRequired => "profile_recovery_required", + } + } + + fn capacity(code: &str) -> Option { + match code { + "browser_capacity_unavailable" => Some(Self::BrowserCapacityUnavailable), + "resources_in_use" => Some(Self::ResourcesInUse), + "profile_recovery_required" => Some(Self::ProfileRecoveryRequired), + _ => None, + } + } } fn browser_open_outcome( @@ -163,59 +215,206 @@ fn browser_launch_reconciliation_pending_outcome() -> serde_json::Value { } impl BrowserOpenFailure { - fn text(status: StatusCode, message: impl Into) -> Self { + fn new(status: StatusCode, public: BrowserOpenFailureBody, diagnostic: anyhow::Error) -> Self { Self { - status, - body: BrowserOpenFailureBody::Text(message.into()), - outcome: browser_terminal_pre_effect_outcome(), + diagnostic, + public: BrowserOpenPublicFailure { + status, + body: public, + outcome: browser_terminal_pre_effect_outcome(), + }, } } - fn json(status: StatusCode, body: serde_json::Value) -> Self { - Self { + fn message( + status: StatusCode, + code: BrowserOpenFailureCode, + message: &'static str, + diagnostic: anyhow::Error, + ) -> Self { + Self::new( status, - body: BrowserOpenFailureBody::Json(body), - outcome: browser_terminal_pre_effect_outcome(), - } + BrowserOpenFailureBody::Message { code, message }, + diagnostic, + ) + } + + fn request(message: &'static str, diagnostic: anyhow::Error) -> Self { + Self::message( + StatusCode::BAD_REQUEST, + BrowserOpenFailureCode::RequestRejected, + message, + diagnostic, + ) + } + + fn runtime(status: StatusCode, diagnostic: impl Into) -> Self { + let diagnostic = diagnostic.into(); + // Preserve Runtime admission guidance as fixed public copy. Even an + // unexpected engine diagnostic here can only select a fixed message. + let message = match diagnostic.as_str() { + "Browser lifecycle already owns a different open intent" => + "Browser lifecycle already owns a different open intent", + "Browser instance already owns an active or in-flight open" => + "Browser instance already owns an active or in-flight open", + "Browser instance already owns an active or launching lifecycle" => + "Browser instance already owns an active or launching lifecycle", + "Browser lifecycle is already active or launching for this verified launch" => + "Browser lifecycle is already active or launching for this verified launch", + "Browser cleanup is pending for this account; no replacement page may open before terminal provider closure" => + "Browser cleanup is pending for this account; wait for cleanup, then open Browser again.", + text if text.starts_with("Browser capacity unavailable:") => + "Browser capacity is full. Close an unused Browser page, then try again.", + _ => "Browser could not open. Try again.", + }; + Self::message( + status, + BrowserOpenFailureCode::RuntimeError, + message, + anyhow::anyhow!(diagnostic), + ) + } + + fn engine(status: StatusCode, diagnostic: anyhow::Error) -> Self { + Self::message( + status, + BrowserOpenFailureCode::ProviderError, + "Browser Engine failed to start cleanly.", + diagnostic, + ) } fn with_outcome(mut self, outcome: serde_json::Value) -> Self { - self.outcome = outcome; + self.public.outcome = outcome; self } - fn provider(scheme: &str, err: anyhow::Error) -> Self { - let (status, message) = gateway_provider_error_tuple(scheme, err); - Self::text(status, message) + fn provider(scheme: &str, diagnostic: anyhow::Error) -> Self { + let status = gateway_provider_error_status(scheme, &diagnostic); + match scheme { + "browser-engine" => Self::engine(status, diagnostic), + "net" => Self::message( + status, + BrowserOpenFailureCode::ProviderError, + "net provider unavailable.", + diagnostic, + ), + "exit" => Self::message( + status, + BrowserOpenFailureCode::ProviderError, + match diagnostic.to_string().as_str() { + "Remote Carrier Exit is not permitted for this principal" => + "Remote Carrier Exit is not permitted for this principal", + "Remote Carrier Exit active stream quota is exhausted" => + "Remote Carrier Exit active stream quota is exhausted", + "Remote Carrier Exit grant is expired" => + "Remote Carrier Exit grant is expired", + "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking" => + "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking", + text if text.starts_with("Selected Browser Exit node does not allow host ") + && text.ends_with("; exit-provider refuses direct host networking") => + "Selected Browser Exit node does not allow this host; exit-provider refuses direct host networking", + _ => "exit provider unavailable.", + }, + diagnostic, + ), + "browser" if diagnostic.to_string() == "Runtime viewer ingress capacity unavailable" => + Self::message( + status, + BrowserOpenFailureCode::RuntimeError, + "Runtime viewer ingress capacity unavailable", + diagnostic, + ), + _ => Self::message( + status, + BrowserOpenFailureCode::ProviderError, + "Browser could not open. Try again.", + diagnostic, + ), + } + } + + fn engine_provider(message: impl Into) -> Self { + Self::provider("browser-engine", anyhow::anyhow!(message.into())) } fn into_response(self) -> Response { - let status = self.status; + let status = self.public.status; (status, Json(self.status_value())).into_response() } - pub(in crate::api::gateway) fn status_value(&self) -> serde_json::Value { - let mut value = match &self.body { - BrowserOpenFailureBody::Text(message) => serde_json::json!({ - "schema": "elastos.browser.open-error/v1", - "ok": false, + // This consuming projection is the single diagnostic boundary for both + // direct HTTP failures and background open-job results. Polling reuses only + // the public value, so it cannot log the diagnostic again. + pub(in crate::api::gateway) fn status_value(self) -> serde_json::Value { + let BrowserOpenPublicFailure { + status, + body, + outcome, + } = self.public; + let mut value = match body { + BrowserOpenFailureBody::Message { code, message } => serde_json::json!({ + "code": code.as_str(), + "message": message, + }), + BrowserOpenFailureBody::Compatibility(error) => { + let mut body = + serde_json::to_value(&error).expect("Browser compatibility error serializes"); + body["message"] = serde_json::json!(error.to_string()); + body["stage"] = serde_json::json!(if matches!( + error, + BrowserCompatibilityError::EngineNotReady { .. } + ) { + "engine_readiness" + } else { + "engine_compatibility" + }); + body + } + BrowserOpenFailureBody::HostSetupRequired { message } => serde_json::json!({ + "code": "browser_host_setup_required", + "stage": "engine_readiness", "message": message, }), - BrowserOpenFailureBody::Json(body) => body.clone(), + BrowserOpenFailureBody::Refused(refusal) => serde_json::json!({ + "code": "launch_refused", + "message": "Browser cannot open.", + "refusal": refusal, + }), + BrowserOpenFailureBody::ExitPolicy { host } => serde_json::json!({ + "code": "exit_policy_blocked", + "message": format!("Browser Exit policy blocked {host}. Runtime keeps direct host networking disabled."), + }), }; - if let Some(object) = value.as_object_mut() { - object - .entry("schema".to_string()) - .or_insert_with(|| serde_json::json!("elastos.browser.open-error/v1")); - object - .entry("ok".to_string()) - .or_insert_with(|| serde_json::json!(false)); - object.insert("outcome".to_string(), self.outcome.clone()); - object.insert( - "http_status".to_string(), - serde_json::json!(self.status.as_u16()), + let code = value["code"] + .as_str() + .expect("closed Browser open failure code"); + if matches!( + code, + "request_rejected" | "profile_transfer_required" | "browser_host_setup_required" + ) { + tracing::debug!(status = status.as_u16(), code, "Browser open rejected"); + } else if code == "runtime_error" + && value["message"] != "Browser could not open. Try again." + { + tracing::debug!( + status = status.as_u16(), + code, + error = %format!("{:#}", self.diagnostic), + "Browser open rejected" + ); + } else { + tracing::warn!( + status = status.as_u16(), + code, + error = %format!("{:#}", self.diagnostic), + "Browser Engine open failed" ); } + value["schema"] = serde_json::json!("elastos.browser.open-error/v1"); + value["ok"] = serde_json::json!(false); + value["outcome"] = outcome; + value["http_status"] = serde_json::json!(status.as_u16()); value } } @@ -426,13 +625,21 @@ pub(super) async fn browser_app_open( let home_token = home_launch_token_header(&headers); let request_origin = match browser_request_origin(&headers) { Ok(origin) => Some(origin), - Err(_) => return (StatusCode::BAD_REQUEST, "invalid gateway origin").into_response(), + Err(err) => { + return BrowserOpenFailure::request("invalid gateway origin", err).into_response() + } }; if input.async_open { let owner_launch_id = authority.verified_context().launch_id(); let browser_instance = match browser_instance_id(input.browser_instance.clone()) { Ok(value) => value, - Err(message) => return (StatusCode::BAD_REQUEST, message).into_response(), + Err(message) => { + return BrowserOpenFailure::request( + "invalid Browser instance binding", + anyhow::anyhow!(message), + ) + .into_response() + } }; let intent_hash = browser_open_intent_hash(&input); let reservation = match create_browser_open_job( @@ -572,13 +779,10 @@ fn browser_host_setup_failure( return None; } crate::setup::linux_host_setup_message(data, platform).map(|message| { - BrowserOpenFailure::json( + BrowserOpenFailure::new( StatusCode::CONFLICT, - serde_json::json!({ - "code": "browser_host_setup_required", - "stage": "engine_readiness", - "message": message, - }), + BrowserOpenFailureBody::HostSetupRequired { message }, + anyhow::anyhow!(message), ) }) } @@ -605,22 +809,25 @@ pub(in crate::api::gateway) async fn execute_browser_open( } = input; let (url, target) = match browser_url_to_stream_target(&requested_url) { Ok(value) => value, - Err(err) => { - return Err(BrowserOpenFailure::text( - StatusCode::BAD_REQUEST, - err.to_string(), - )) - } + Err(err) => return Err(BrowserOpenFailure::request( + "Only http and https addresses with a host and known port can be opened by Browser.", + err, + )), }; if let Err(err) = validate_browser_launch_contract(display_mode, guarantee_level) { - return Err(BrowserOpenFailure::text( - StatusCode::BAD_REQUEST, - err.to_string(), + return Err(BrowserOpenFailure::request( + "Choose a supported display_mode and guarantee_level; operator_rbi requires webrtc_remote_display.", + err, )); } let requested_adapter_id = match browser_engine_adapter_id(adapter_id) { Ok(value) => value, - Err(message) => return Err(BrowserOpenFailure::text(StatusCode::BAD_REQUEST, message)), + Err(message) => { + return Err(BrowserOpenFailure::request( + "invalid adapter_id", + anyhow::anyhow!(message), + )) + } }; if requested_adapter_id .as_deref() @@ -652,19 +859,29 @@ pub(in crate::api::gateway) async fn execute_browser_open( let stream_nonce = browser_stream_nonce(&open_request_id); let remote_exit_id = match browser_remote_exit_id(remote_exit_id) { Ok(value) => value, - Err(message) => return Err(BrowserOpenFailure::text(StatusCode::BAD_REQUEST, message)), + Err(message) => { + return Err(BrowserOpenFailure::request( + "invalid remote_exit_id", + anyhow::anyhow!(message), + )) + } }; let browser_instance = match browser_instance_id(browser_instance) { Ok(value) => value, - Err(message) => return Err(BrowserOpenFailure::text(StatusCode::BAD_REQUEST, message)), + Err(message) => { + return Err(BrowserOpenFailure::request( + "invalid Browser instance binding", + anyhow::anyhow!(message), + )) + } }; let viewport = match viewport { Some(viewport) => match browser_viewport_value(viewport) { Ok(value) => Some(value), Err(err) => { - return Err(BrowserOpenFailure::text( - StatusCode::BAD_REQUEST, - err.to_string(), + return Err(BrowserOpenFailure::request( + "Browser viewport must be within 320x240 and 3840x2160.", + err, )) } }, @@ -680,7 +897,24 @@ pub(in crate::api::gateway) async fn execute_browser_open( .await { Ok(choice) => choice, - Err(error) => return Err(BrowserOpenFailure::provider("browser-engine", error)), + Err(error) => { + if let Some(transfer) = + error.downcast_ref::() + { + return Err(BrowserOpenFailure::message( + StatusCode::INTERNAL_SERVER_ERROR, + BrowserOpenFailureCode::ProfileTransferRequired, + match transfer { + gateway_browser_remote::ProfileTransferRequired::OwningRuntime => + "This Browser profile requires an approved transfer from its owning Runtime", + gateway_browser_remote::ProfileTransferRequired::BeforeRemotePlacement => + "This Browser profile requires an approved transfer before remote placement", + }, + error, + )); + } + return Err(BrowserOpenFailure::provider("browser-engine", error)); + } }; let engine_route_provider = if let Some(choice) = &remote_choice { choice.2.clone() @@ -714,18 +948,11 @@ pub(in crate::api::gateway) async fn execute_browser_open( let (adapter_id, verified_rootfs) = match resolved_adapter { Ok(adapter_id) => adapter_id, Err(error) => { - let mut body = - serde_json::to_value(&error).expect("Browser compatibility error serializes"); - body["message"] = serde_json::json!(error.to_string()); - body["stage"] = serde_json::json!(if matches!( - error, - BrowserCompatibilityError::EngineNotReady { .. } - ) { - "engine_readiness" - } else { - "engine_compatibility" - }); - return Err(BrowserOpenFailure::json(StatusCode::BAD_REQUEST, body)); + return Err(BrowserOpenFailure::new( + StatusCode::BAD_REQUEST, + BrowserOpenFailureBody::Compatibility(error.clone()), + error.into(), + )); } }; let (_, profile) = @@ -761,7 +988,7 @@ pub(in crate::api::gateway) async fn execute_browser_open( let launch_reservation = match reserve_browser_launch(&state.data_dir, &context.principal_id, lifecycle).await { Ok(reservation) => reservation, - Err((status, message)) => return Err(BrowserOpenFailure::text(status, message)), + Err((status, message)) => return Err(BrowserOpenFailure::runtime(status, message)), }; if let Err((status, message)) = append_browser_effect_audit_or_500( &state.data_dir, @@ -779,7 +1006,7 @@ pub(in crate::api::gateway) async fn execute_browser_open( }, ) { release_browser_launch(&launch_reservation).await; - return Err(BrowserOpenFailure::text(status, message)); + return Err(BrowserOpenFailure::runtime(status, message)); } mark_browser_launch_preparing_image(&launch_reservation).await; let stream_request = serde_json::json!({ @@ -795,7 +1022,17 @@ pub(in crate::api::gateway) async fn execute_browser_open( Ok(receipt) => receipt, Err((provider, err)) => { release_browser_launch(&launch_reservation).await; - return Err(BrowserOpenFailure::provider(provider, err)); + let mut failure = BrowserOpenFailure::provider(provider, err); + if failure.public.status == StatusCode::FORBIDDEN { + failure.public.body = BrowserOpenFailureBody::ExitPolicy { + host: url::Url::parse(&url) + .expect("validated Browser URL") + .host_str() + .expect("validated Browser host") + .to_owned(), + }; + } + return Err(failure); } }; let stream_cleanup = browser_stream_cleanup(&stream_session); @@ -844,7 +1081,6 @@ pub(in crate::api::gateway) async fn execute_browser_open( &profile, &stream_session, &serde_json::json!({"url":url,"viewport":viewport,"display_mode":display_mode,"guarantee_level":guarantee_level, "owner_launch_id":authority.verified_context().launch_id(),"browser_instance":browser_instance})).await .map(|(transport, viewer)| {remote_viewer = Some(viewer); Some(transport)}) - .map_err(|error| error.to_string()) } else { prepare_browser_vz_transport_launch( &state.data_dir, @@ -861,10 +1097,11 @@ pub(in crate::api::gateway) async fn execute_browser_open( .unwrap_or_default(), }, ) + .map_err(anyhow::Error::msg) }; let vz_transport_launch = match prepared_transport { Ok(launch) => launch, - Err(message) => { + Err(error) => { let outcome = release_browser_open_resources( state, &launch_reservation, @@ -872,10 +1109,7 @@ pub(in crate::api::gateway) async fn execute_browser_open( false, ) .await; - return Err( - BrowserOpenFailure::provider("browser", anyhow::anyhow!(message)) - .with_outcome(outcome), - ); + return Err(BrowserOpenFailure::provider("browser", error).with_outcome(outcome)); } }; if let Some(transport) = vz_transport_launch.as_ref() { @@ -963,7 +1197,7 @@ pub(in crate::api::gateway) async fn execute_browser_open( false, ) .await; - return Err(BrowserOpenFailure::text(status, message).with_outcome(outcome)); + return Err(BrowserOpenFailure::runtime(status, message).with_outcome(outcome)); } }; if vz_transport_launch.is_some() { @@ -987,9 +1221,10 @@ pub(in crate::api::gateway) async fn execute_browser_open( ); } } - let engine_response = match browser_provider_resource_response(state, engine_call).await { + let engine_response = match browser_provider_resource_result(state, engine_call).await { Ok(value) => value, - Err((status, message)) => { + Err(failure) => { + let message = format!("{:#}", failure.diagnostic); let outcome = reconcile_dispatched_browser_launch_failure( state, &launch_reservation, @@ -1000,7 +1235,10 @@ pub(in crate::api::gateway) async fn execute_browser_open( &message, ) .await; - return Err(BrowserOpenFailure::text(status, message).with_outcome(outcome)); + return Err( + BrowserOpenFailure::engine(failure.status, failure.diagnostic) + .with_outcome(outcome), + ); } }; if engine_response @@ -1024,6 +1262,32 @@ pub(in crate::api::gateway) async fn execute_browser_open( &engine_response, ) .await; + if let Some(refusal) = engine_response + .get("refusal") + .and_then(elastos_common::browser_protocol::BrowserLaunchRefusal::from_value) + { + let outcome = match exact_did_not_act { + Some(outcome) => outcome, + None => { + reconcile_dispatched_browser_launch_failure( + state, + &launch_reservation, + &context.principal_id, + authority.verified_context().launch_id(), + &engine_stream_id, + stream_cleanup.clone(), + "Browser launch refused", + ) + .await + } + }; + return Err(BrowserOpenFailure::new( + StatusCode::SERVICE_UNAVAILABLE, + BrowserOpenFailureBody::Refused(refusal), + anyhow::anyhow!(message.to_string()), + ) + .with_outcome(outcome)); + } if matches!( code, "engine_unavailable" | "byte_transport_unavailable" | "display_session_unavailable" @@ -1043,16 +1307,12 @@ pub(in crate::api::gateway) async fn execute_browser_open( .await } }; - return Err(BrowserOpenFailure::provider( - "browser-engine", - anyhow::anyhow!("browser-engine provider unavailable: {}", message), - ) + return Err(BrowserOpenFailure::engine_provider(format!( + "browser-engine provider unavailable: {message}", + )) .with_outcome(outcome)); } - if matches!( - code, - "browser_capacity_unavailable" | "resources_in_use" | "profile_recovery_required" - ) { + if let Some(public_code) = BrowserOpenFailureCode::capacity(code) { let outcome = match exact_did_not_act { Some(outcome) => outcome, None => { @@ -1068,14 +1328,11 @@ pub(in crate::api::gateway) async fn execute_browser_open( .await } }; - return Err(BrowserOpenFailure::json( + return Err(BrowserOpenFailure::message( StatusCode::SERVICE_UNAVAILABLE, - serde_json::json!({ - "schema": "elastos.browser.open-error/v1", - "ok": false, - "code": code, - "message": message, - }), + public_code, + "Browser launch refused.", + anyhow::anyhow!(message.to_string()), ) .with_outcome(outcome)); } @@ -1094,11 +1351,7 @@ pub(in crate::api::gateway) async fn execute_browser_open( .await } }; - return Err(BrowserOpenFailure::provider( - "browser-engine", - anyhow::anyhow!(message.to_string()), - ) - .with_outcome(outcome)); + return Err(BrowserOpenFailure::engine_provider(message).with_outcome(outcome)); } if let Some(message) = provider_response_error_message(&engine_response) { let outcome = reconcile_dispatched_browser_launch_failure( @@ -1111,10 +1364,7 @@ pub(in crate::api::gateway) async fn execute_browser_open( &message, ) .await; - return Err( - BrowserOpenFailure::provider("browser-engine", anyhow::anyhow!(message)) - .with_outcome(outcome), - ); + return Err(BrowserOpenFailure::engine_provider(message).with_outcome(outcome)); } let raw_engine_page = match provider_response_data(&engine_response) { Some(data) => data, @@ -1451,7 +1701,7 @@ pub(in crate::api::gateway) async fn execute_browser_open( true, ) .await; - return Err(BrowserOpenFailure::text(status, message).with_outcome(outcome)); + return Err(BrowserOpenFailure::runtime(status, message).with_outcome(outcome)); } Ok(serde_json::json!({ "schema": "elastos.browser.open-result/v1", @@ -3327,7 +3577,6 @@ async fn release_browser_page_and_stream_for_principal( let _ = release_browser_page_for_principal(&state.data_dir, page_id, principal_id, owner_launch_id) .await; - forget_browser_open_job_for_owner(&state.data_dir, principal_id, owner_launch_id).await; cleanup_result } @@ -4054,6 +4303,11 @@ pub(super) async fn browser_app_page_close( } else { close_browser_stream_cleanup(&state, page_cleanup.stream_cleanup).await }; + // Explicit close owns result retirement. Automatic open-failure cleanup + // keeps the job so its pending callback can publish the public error. + forget_browser_open_job_for_owner(&state.data_dir, &principal_id, &cleanup_owner_launch_id) + .await; + let terminal = if engine_result.is_ok() && stream_result.is_ok() { commit_browser_terminal_cleanup( &state, @@ -4663,12 +4917,271 @@ fn browser_display_error_response(error: BrowserDisplayError) -> Response { mod browser_open_outcome_tests { use super::*; + #[test] + fn runtime_viewer_ingress_capacity_copy_keeps_its_cause_private() { + let diagnostic = anyhow::anyhow!("private listener configuration") + .context("Runtime viewer ingress capacity unavailable"); + let failure = BrowserOpenFailure::provider("browser", diagnostic); + assert_eq!(failure.diagnostic.chain().count(), 2); + let public = failure.status_value(); + assert_eq!( + public["message"], + "Runtime viewer ingress capacity unavailable" + ); + assert!(!public + .to_string() + .contains("private listener configuration")); + } + + #[test] + fn exit_failure_copy_preserves_each_known_reason_and_keeps_diagnostics_private() { + for message in [ + "Remote Carrier Exit is not permitted for this principal", + "Remote Carrier Exit active stream quota is exhausted", + "Remote Carrier Exit grant is expired", + "No Browser Exit backend is configured for open_stream; exit-provider refuses direct host networking", + ] { + let public = BrowserOpenFailure::provider("exit", anyhow::anyhow!(message)).status_value(); + assert_eq!(public["message"], message); + } + let public = BrowserOpenFailure::provider("exit", anyhow::anyhow!( + "exit provider unavailable: No Browser Exit provider is configured for stream; /private/exit/socket failed" + )).status_value(); + assert_eq!(public["message"], "exit provider unavailable."); + assert!(!public.to_string().contains("/private/exit/socket")); + } + + #[test] + fn selected_exit_host_refusal_keeps_specific_public_copy() { + let diagnostic = anyhow::anyhow!("private Exit configuration").context( + "Selected Browser Exit node does not allow host example.com; exit-provider refuses direct host networking" + ); + let public = BrowserOpenFailure::provider("exit", diagnostic).status_value(); + assert_eq!( + public["message"], + "Selected Browser Exit node does not allow this host; exit-provider refuses direct host networking" + ); + assert!(!public.to_string().contains("private Exit configuration")); + } + + #[tokio::test] + async fn engine_provider_constructor_keeps_all_diagnostics_out_of_response_bodies() { + for message in [ + "browser-engine provider unavailable: /private/engine/rootfs.img", + "private host blocked: /private/engine/rootfs.img", + "invalid engine reply: /private/engine/rootfs.img", + "page not found: /private/engine/rootfs.img", + "engine failed: /private/engine/rootfs.img", + "This Browser profile requires an approved transfer: /private/engine/rootfs.img", + ] { + let expected_status = + gateway_provider_error_tuple("browser-engine", anyhow::anyhow!(message)).0; + let response = BrowserOpenFailure::provider("browser-engine", anyhow::anyhow!(message)) + .into_response(); + assert_eq!(response.status(), expected_status); + let body = axum::body::to_bytes(response.into_body(), usize::MAX) + .await + .unwrap(); + assert!(!String::from_utf8_lossy(&body).contains("/private/engine/rootfs.img")); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + payload["message"], + "Browser Engine failed to start cleanly." + ); + assert_eq!(payload["code"], "provider_error"); + } + } + + #[test] + fn engine_failure_projection_logs_private_error_chain_once() { + // Parallel route tests use this callsite too. Keep the capture in a + // fresh process with one subscriber and one selected test. + const CHILD: &str = "ELASTOS_TEST_BROWSER_OPEN_LOG_CHILD"; + if std::env::var_os(CHILD).is_none() { + let qualified = concat!( + module_path!(), + "::engine_failure_projection_logs_private_error_chain_once" + ); + let name = qualified.split_once("::").unwrap().1; + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", name, "--nocapture", "--color", "never"]) + .env(CHILD, "1") + .output() + .unwrap(); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!( + output.status.success() && stdout.contains("1 passed;"), + "{stdout}\n{}", + String::from_utf8_lossy(&output.stderr) + ); + return; + } + #[derive(Clone)] + struct LogWriter(std::sync::Arc>>); + impl std::io::Write for LogWriter { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + let output = std::sync::Arc::new(std::sync::Mutex::new(Vec::new())); + let writer = LogWriter(std::sync::Arc::clone(&output)); + let subscriber = tracing_subscriber::fmt() + .with_max_level(tracing::Level::DEBUG) + .with_ansi(false) + .without_time() + .with_writer(move || writer.clone()) + .finish(); + let _subscriber = tracing::subscriber::set_default(subscriber); + let message = "browser-engine provider unavailable: /private/engine/rootfs.img"; + let failure = BrowserOpenFailure::provider( + "browser-engine", + anyhow::anyhow!(message) + .context("browser-engine provider unavailable: open request failed"), + ); + assert_eq!(failure.public.status, StatusCode::SERVICE_UNAVAILABLE); + assert!( + output.lock().unwrap().is_empty(), + "constructors keep diagnostics for the projection" + ); + assert!(!failure.status_value().to_string().contains(message)); + let log = String::from_utf8(output.lock().unwrap().clone()).unwrap(); + assert!(log.contains("WARN"), "{log}"); + assert!(log.contains("Browser Engine open failed"), "{log}"); + assert!(log.contains("status=503"), "{log}"); + assert!(log.contains(message), "{log}"); + assert!(log.contains("open request failed"), "{log}"); + assert_eq!( + log.matches("Browser Engine open failed").count(), + 1, + "{log}" + ); + + for (status, message, outcome, level) in [ + ( + StatusCode::INTERNAL_SERVER_ERROR, + "Browser effect audit failed: audit storage unavailable", + browser_terminal_pre_effect_outcome(), + "WARN", + ), + ( + StatusCode::INTERNAL_SERVER_ERROR, + "Browser effect audit failed: audit storage unavailable", + browser_terminal_post_effect_outcome(), + "WARN", + ), + ( + StatusCode::CONFLICT, + "Browser lifecycle already owns a different open intent", + browser_terminal_pre_effect_outcome(), + "DEBUG", + ), + ] { + output.lock().unwrap().clear(); + let mut failure = + BrowserOpenFailure::runtime(status, message).with_outcome(outcome.clone()); + failure.diagnostic = failure.diagnostic.context("private Runtime fault context"); + assert!(output.lock().unwrap().is_empty()); + let public = failure.status_value(); + assert_eq!(public["http_status"], status.as_u16()); + assert_eq!(public["outcome"], outcome); + assert!(!public.to_string().contains("private Runtime fault context")); + if level == "WARN" { + assert_eq!(public["message"], "Browser could not open. Try again."); + assert!(!public.to_string().contains(message)); + } else { + assert_eq!(public["message"], message); + } + let log = String::from_utf8(output.lock().unwrap().clone()).unwrap(); + assert_eq!(log.lines().count(), 1, "{log}"); + assert!(log.contains(level), "{log}"); + assert!(log.contains("code=\"runtime_error\""), "{log}"); + assert!(log.contains("error="), "{log}"); + assert_eq!(log.matches(message).count(), 1, "{log}"); + assert_eq!( + log.matches("private Runtime fault context").count(), + 1, + "{log}" + ); + if level == "DEBUG" { + assert!(!log.contains("WARN"), "{log}"); + } + } + + output.lock().unwrap().clear(); + let data = tempfile::tempdir().unwrap(); + let failure = browser_host_setup_failure(data.path(), "linux-arm64", None).unwrap(); + assert!(output.lock().unwrap().is_empty()); + let public = failure.status_value(); + let log = String::from_utf8(output.lock().unwrap().clone()).unwrap(); + assert!(log.contains("DEBUG"), "{log}"); + assert!(!log.contains("WARN"), "{log}"); + assert!(log.contains("browser_host_setup_required"), "{log}"); + assert_eq!(log.matches("Browser open rejected").count(), 1, "{log}"); + for _ in 0..2 { + let polled = browser_open_status_value( + "setup-refusal", + BrowserOpenJobSnapshot::Failed(public.clone()), + ); + assert_eq!(polled["error"], public); + } + assert_eq!(*output.lock().unwrap(), log.as_bytes()); + } + + #[test] + fn runtime_admission_copy_keeps_diagnostic_text_private() { + let conflict = "Browser lifecycle already owns a different open intent"; + assert_eq!( + BrowserOpenFailure::runtime(StatusCode::CONFLICT, conflict).status_value()["message"], + conflict, + ); + for diagnostic in [ + format!("{conflict}: /private/engine/rootfs.img"), + "Browser capacity unavailable: /private/engine/rootfs.img".to_string(), + "/private/engine/rootfs.img".to_string(), + ] { + let public = BrowserOpenFailure::runtime(StatusCode::SERVICE_UNAVAILABLE, diagnostic) + .status_value(); + assert!(!public.to_string().contains("/private/engine/rootfs.img")); + } + } + + #[test] + fn engine_error_keeps_status_while_projection_keeps_diagnostics_private() { + for (message, status) in [ + ( + "browser-engine provider unavailable: private diagnostic", + StatusCode::SERVICE_UNAVAILABLE, + ), + ( + "private host blocked: private diagnostic", + StatusCode::FORBIDDEN, + ), + ( + "invalid engine reply: private diagnostic", + StatusCode::BAD_REQUEST, + ), + ("page not found: private diagnostic", StatusCode::NOT_FOUND), + ("private diagnostic", StatusCode::INTERNAL_SERVER_ERROR), + ] { + let failure = BrowserOpenFailure::engine_provider(message); + assert_eq!(failure.public.status, status); + assert_eq!( + failure.status_value()["message"], + "Browser Engine failed to start cleanly." + ); + } + } + #[test] fn unprepared_linux_browser_open_explains_setup_and_restart_before_acquiring_effects() { let data = tempfile::tempdir().unwrap(); for adapter in [None, Some("browser-vm-product")] { let failure = browser_host_setup_failure(data.path(), "linux-arm64", adapter).unwrap(); - assert_eq!(failure.status, StatusCode::CONFLICT); + assert_eq!(failure.public.status, StatusCode::CONFLICT); let body = failure.status_value(); assert_eq!(body["code"], "browser_host_setup_required"); assert_eq!(body["stage"], "engine_readiness"); @@ -4686,13 +5199,13 @@ mod browser_open_outcome_tests { #[test] fn failed_open_serializes_cleanup_pending_separately_from_pre_effect_failure() { - let pending = BrowserOpenFailure::text( + let pending = BrowserOpenFailure::runtime( StatusCode::SERVICE_UNAVAILABLE, "Browser cleanup remains owned by Runtime", ) .with_outcome(browser_cleanup_pending_outcome(true, true, false)) .status_value(); - let pre_effect = BrowserOpenFailure::text( + let pre_effect = BrowserOpenFailure::runtime( StatusCode::SERVICE_UNAVAILABLE, "Browser VM was not acquired", ) diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs b/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs index 2eabff5bb..5c5e060bb 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_remote.rs @@ -1601,6 +1601,27 @@ pub(super) fn unresolved_preparation( })) } +#[derive(Debug)] +pub(super) enum ProfileTransferRequired { + OwningRuntime, + BeforeRemotePlacement, +} + +impl std::fmt::Display for ProfileTransferRequired { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(match self { + Self::OwningRuntime => { + "This Browser profile requires an approved transfer from its owning Runtime" + } + Self::BeforeRemotePlacement => { + "This Browser profile requires an approved transfer before remote placement" + } + }) + } +} + +impl std::error::Error for ProfileTransferRequired {} + pub(super) fn require_profile_placement( data_dir: &FsPath, principal: &str, @@ -1618,7 +1639,7 @@ pub(super) fn require_profile_placement( !placements .iter() .any(|p| p.principal_id == principal && peer != Some(p.peer.as_str())), - "This Browser profile requires an approved transfer from its owning Runtime" + ProfileTransferRequired::OwningRuntime ); ensure!( !records @@ -1626,7 +1647,7 @@ pub(super) fn require_profile_placement( .any(|binding| binding.principal_id == principal && binding.dispatch_started && peer != binding.grant["peer_did"].as_str()), - "This Browser profile requires an approved transfer from its owning Runtime" + ProfileTransferRequired::OwningRuntime ); Ok(()) } @@ -1686,7 +1707,7 @@ pub(super) async fn select( browser_profile_launch_descriptor(&gateway.data_dir, &context.principal_id)?; ensure!( !local_profile.exists(), - "This Browser profile requires an approved transfer before remote placement" + ProfileTransferRequired::BeforeRemotePlacement ); Ok(Some((grant, adapter_id, id))) } diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_response.rs b/elastos/crates/elastos-server/src/api/gateway_browser_response.rs index 4e7e9852e..3c256d79f 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_response.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_response.rs @@ -53,15 +53,34 @@ pub(in crate::api::gateway) fn browser_provider_resource_call( }) } +#[derive(Debug)] +pub(in crate::api::gateway) struct BrowserProviderResourceFailure { + pub(in crate::api::gateway) status: StatusCode, + pub(in crate::api::gateway) diagnostic: anyhow::Error, + response_message: String, +} + pub(in crate::api::gateway) async fn browser_provider_resource_response( state: &GatewayState, call: BrowserProviderResourceCall, ) -> Result { + browser_provider_resource_result(state, call) + .await + .map_err(|failure| (failure.status, failure.response_message)) +} + +// Keep the original cause until the operation chooses its public projection. +pub(in crate::api::gateway) async fn browser_provider_resource_result( + state: &GatewayState, + call: BrowserProviderResourceCall, +) -> Result { let registry = state.provider_registry.as_ref().ok_or_else(|| { - ( - StatusCode::SERVICE_UNAVAILABLE, - format!("{} provider unavailable", call.scheme), - ) + let response_message = format!("{} provider unavailable", call.scheme); + BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + diagnostic: anyhow::anyhow!(response_message.clone()), + response_message, + } })?; if call.scheme == "browser-engine" && (call.request.get("page_id").is_some() @@ -71,34 +90,40 @@ pub(in crate::api::gateway) async fn browser_provider_resource_response( Ok(Some(binding)) => { return gateway_browser_remote::dispatch_consumer(state, &binding, &call.request) .await - .map_err(|_| { - ( - StatusCode::SERVICE_UNAVAILABLE, - "Remote Runtime Engine operation is unavailable or pending settlement" - .into(), - ) + .map_err(|diagnostic| { + let message = + "Remote Runtime Engine operation is unavailable or pending settlement"; + BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + diagnostic: diagnostic.context(message), + response_message: message.into(), + } }) } Ok(None) => {} - Err(_) => { - return Err(( - StatusCode::SERVICE_UNAVAILABLE, - "Remote Runtime Engine ownership is unavailable".into(), - )) + Err(diagnostic) => { + let message = "Remote Runtime Engine ownership is unavailable"; + return Err(BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + diagnostic: diagnostic.context(message), + response_message: message.into(), + }); } } } registry .send_raw(call.scheme, &call.request) .await - .map_err(|err| { - ( - StatusCode::SERVICE_UNAVAILABLE, - format!( - "{} provider unavailable for {}: {}", - call.scheme, call.resource, err - ), - ) + .map_err(|diagnostic| BrowserProviderResourceFailure { + status: StatusCode::SERVICE_UNAVAILABLE, + response_message: format!( + "{} provider unavailable for {}: {}", + call.scheme, call.resource, diagnostic + ), + diagnostic: anyhow::anyhow!(diagnostic).context(format!( + "{} provider unavailable for {}", + call.scheme, call.resource + )), }) } diff --git a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs index f37412e02..dd60a7d5e 100644 --- a/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs +++ b/elastos/crates/elastos-server/src/api/gateway_browser_route_tests.rs @@ -1,5 +1,397 @@ use super::*; +fn browser_open_response_consumers(status: StatusCode, body: &[u8]) -> serde_json::Value { + use std::io::Write; + let mut child = std::process::Command::new("node") + .args([ + "--input-type=module", + "-e", + r#" +import { readFileSync } from 'node:fs'; +import { pathToFileURL } from 'node:url'; +const root = process.argv[1]; +const { friendlyOpenError, isAuthoritySessionError, runtimeOpenOutcome } = + await import(pathToFileURL(`${root}/capsules/browser/browser/browser-status.js`)); +const { browserOpenResponseEvidence } = + await import(pathToFileURL(`${root}/scripts/lib/browser-open-failure.mjs`)); +const { createRuntimeApi } = + await import(pathToFileURL(`${root}/capsules/browser/browser/browser-runtime-api.js`)); +const { status, body } = JSON.parse(readFileSync(0, 'utf8')); +globalThis.fetch = async () => new Response(body, { status }); +let error; +try { await createRuntimeApi({}).fetchJson('/api/apps/browser/open'); } +catch (failure) { error = failure; } +console.log(JSON.stringify({ + authority: isAuthoritySessionError(error), message: friendlyOpenError(error), + outcome: runtimeOpenOutcome(error), + evidence: await browserOpenResponseEvidence({ + json: async () => JSON.parse(body), text: async () => body, + }), +})); +"#, + ]) + .arg(concat!(env!("CARGO_MANIFEST_DIR"), "/../../..")) + .stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()) + .stderr(std::process::Stdio::piped()) + .spawn() + .unwrap(); + child + .stdin + .take() + .unwrap() + .write_all( + json!({"status": status.as_u16(), "body": std::str::from_utf8(body).unwrap()}) + .to_string() + .as_bytes(), + ) + .unwrap(); + let output = child.wait_with_output().unwrap(); + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + serde_json::from_slice(&output.stdout).unwrap() +} + +#[tokio::test] +async fn test_browser_open_expired_token_reopens_from_home_without_engine_warning() { + let Some(log) = browser_open_route_log( + "test_browser_open_expired_token_reopens_from_home_without_engine_warning", + ) else { + return; + }; + for after_admission in [false, true] { + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let context = + runtime_wallet_authority_for_app_token(dir.path(), BROWSER_CAPSULE_ID, &token) + .home_launch_context(); + let (app, token) = if after_admission { + (gateway_router(test_state(dir.path())), token) + } else { + // Mount the route itself: the outer admission gate deliberately + // gives an already-expired token a generic refusal. + ( + axum::Router::new() + .route( + "/api/apps/browser/open", + axum::routing::post(gateway_browser::browser_app_open), + ) + .with_state(test_state(dir.path())), + issue_expired_home_launch_token_with_context( + dir.path(), + BROWSER_CAPSULE_ID, + &context, + ) + .unwrap(), + ) + }; + let data_dir = dir.path().to_path_buf(); + let body = Body::from_stream(futures_lite::stream::unfold( + Some((data_dir, context)), + move |state| async move { + let (data_dir, context) = state?; + if after_admission { + // Real gateway admission passes first. Expire sign-in when + // JSON extraction reads the body, before the handler checks it. + let now = crate::auth::now_ts(); + let mut grant = + crate::auth::load_active_session_grant(&data_dir, &context.session_id, now) + .unwrap(); + grant.expires_at = now; + crate::auth::store_session_grant(&data_dir, grant).unwrap(); + } + Some((Ok::<_, std::io::Error>(axum::body::Bytes::from_static( + br#"{"url":"https://example.com/","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi","async_open":true}"#, + )), None)) + }, + )); + let response = app + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token) + .header(CONTENT_TYPE, "application/json") + .body(body) + .unwrap(), + ) + .await + .unwrap(); + let status = response.status(); + assert_eq!(status, StatusCode::FORBIDDEN); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + let consumer = browser_open_response_consumers(status, &body); + assert_eq!( + consumer["authority"], + true, + "{}", + String::from_utf8_lossy(&body) + ); + assert_eq!( + consumer["message"], + "Browser session expired. Reopening from Home..." + ); + } + assert!(!String::from_utf8(log.lock().unwrap().clone()) + .unwrap() + .contains("Browser Engine open failed")); +} + +#[derive(Clone)] +struct BrowserOpenLogWriter(Arc>>); + +#[tokio::test] +async fn test_browser_open_validation_errors_do_not_warn_about_engine_failure() { + let Some(log) = browser_open_route_log( + "test_browser_open_validation_errors_do_not_warn_about_engine_failure", + ) else { + return; + }; + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let app = gateway_router(test_state(dir.path())); + for mut input in [ + json!({"url":"file:///private/browser"}), + json!({"url":"https://example.com/", "display_mode":"native_surface"}), + json!({"url":"https://example.com/", "async_open":true, "browser_instance":"invalid"}), + ] { + input + .as_object_mut() + .unwrap() + .entry("display_mode") + .or_insert(json!("webrtc_remote_display")); + input["guarantee_level"] = json!("operator_rbi"); + let response = app + .clone() + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token.clone()) + .header(CONTENT_TYPE, "application/json") + .body(Body::from(input.to_string())) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::BAD_REQUEST); + } + let captured = String::from_utf8(log.lock().unwrap().clone()).unwrap(); + assert!( + !captured.contains("Browser Engine open failed"), + "{captured}" + ); +} + +impl std::io::Write for BrowserOpenLogWriter { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } +} + +fn browser_open_route_log(test: &str) -> Option>>> { + // A fresh process gives spawned open jobs and the route one subscriber, + // independent of parallel tests and tracing's cached callsite interests. + const CHILD: &str = "ELASTOS_TEST_BROWSER_OPEN_ROUTE_LOG_CHILD"; + if std::env::var(CHILD).as_deref() != Ok(test) { + let name = format!("{}::{test}", module_path!()); + let name = name.split_once("::").unwrap().1; + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", name, "--nocapture", "--color", "never"]) + .env(CHILD, test) + .output() + .unwrap(); + let stdout = String::from_utf8_lossy(&output.stdout); + assert!( + output.status.success() && stdout.contains("1 passed;"), + "{stdout}\n{}", + String::from_utf8_lossy(&output.stderr) + ); + return None; + } + let output = Arc::new(std::sync::Mutex::new(Vec::new())); + let writer = BrowserOpenLogWriter(Arc::clone(&output)); + tracing::subscriber::set_global_default( + tracing_subscriber::fmt() + .with_max_level(tracing::Level::WARN) + .with_ansi(false) + .without_time() + .with_writer(move || writer.clone()) + .finish(), + ) + .unwrap(); + Some(output) +} + +async fn browser_open_failure_log_route( + async_open: bool, + url: &str, + diagnostic: &str, + code: &str, + log: &Arc>>, +) { + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let (state, _, _) = browser_engine_reconciliation_test_state( + dir.path(), + if code == "provider_error" { + MockDispatchedBrowserLaunchFailure::ResponseLoss + } else { + MockDispatchedBrowserLaunchFailure::DidNotActResourcesInUse + }, + ) + .await; + let app = gateway_router(state); + let response = app + .clone() + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token.clone()) + .header(CONTENT_TYPE, "application/json") + .body(Body::from( + json!({ + "url": url, + "display_mode": "webrtc_remote_display", + "guarantee_level": "operator_rbi", + "async_open": async_open, + }) + .to_string(), + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!( + response.status(), + if async_open { + StatusCode::ACCEPTED + } else { + StatusCode::SERVICE_UNAVAILABLE + } + ); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + let mut payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + if async_open { + let status_url = payload["status_url"].as_str().unwrap().to_string(); + let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(10); + loop { + let response = app + .clone() + .oneshot( + test_browser_request("localhost:61180", "null") + .uri(&status_url) + .header("x-elastos-home-token", token.clone()) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + let status = response.status(); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + assert_eq!(status, StatusCode::OK, "{}", String::from_utf8_lossy(&body)); + payload = serde_json::from_slice(&body).unwrap(); + if payload["status"] == "failed" { + payload = payload["error"].take(); + break; + } + assert!(tokio::time::Instant::now() < deadline, "{payload}"); + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + } + let captured = String::from_utf8(log.lock().unwrap().clone()).unwrap(); + let events: Vec<_> = captured + .lines() + .filter(|line| line.contains("Browser Engine open failed")) + .collect(); + assert_eq!(events.len(), 1, "{captured}"); + let event = events[0]; + assert!(event.contains("WARN"), "{event}"); + assert!(event.contains("status=503"), "{event}"); + assert!(event.contains(&format!("code=\"{code}\"")), "{event}"); + assert!(event.contains(diagnostic), "{event}"); + // Assert the complete public projection, including cleanup ownership. + assert_eq!( + payload, + json!({ + "schema": "elastos.browser.open-error/v1", "ok": false, + "code": code, + "message": if code == "provider_error" { + "Browser Engine failed to start cleanly." + } else { + "Browser launch refused." + }, + "http_status": 503, + "outcome": { + "schema": "elastos.browser.open-outcome/v1", + "state": "terminal_post_effect_cleanup", + "effects": {"page_acquired": code == "provider_error", "vm_acquired": code == "provider_error", "stream_acquired": true}, + }, + }) + ); + assert_eq!( + browser_launch_reconciliation_obligation_count(dir.path()).await, + 0 + ); + log.lock().unwrap().clear(); +} + +#[tokio::test] +async fn test_browser_open_transport_failure_logs_private_diagnostic_once() { + let Some(log) = + browser_open_route_log("test_browser_open_transport_failure_logs_private_diagnostic_once") + else { + return; + }; + for async_open in [false, true] { + browser_open_failure_log_route( + async_open, + "https://response-loss.invalid/", + "simulated browser-engine launch response loss", + "provider_error", + &log, + ) + .await; + } +} + +#[tokio::test] +async fn test_browser_open_capacity_failure_logs_private_diagnostic_once() { + let Some(log) = + browser_open_route_log("test_browser_open_capacity_failure_logs_private_diagnostic_once") + else { + return; + }; + for async_open in [false, true] { + browser_open_failure_log_route( + async_open, + "https://resources-in-use.invalid/", + "simulated Browser VM resource lease conflict", + "resources_in_use", + &log, + ) + .await; + } +} + #[derive(Default)] struct InspectionTestProvider { calls: std::sync::atomic::AtomicUsize, @@ -1064,8 +1456,12 @@ async fn test_browser_open_fails_closed_without_attached_engine_transport() { let body = axum::body::to_bytes(response.into_body(), usize::MAX) .await .unwrap(); - let message = String::from_utf8(body.to_vec()).unwrap(); - assert!(message.contains("adapter_ipc")); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + payload["message"], + "Browser Engine failed to start cleanly." + ); + assert!(!String::from_utf8_lossy(&body).contains("adapter_ipc")); } #[tokio::test] @@ -1229,7 +1625,7 @@ async fn test_browser_open_returns_forbidden_when_exit_policy_blocks_host() { .header("x-elastos-home-token", token) .header(CONTENT_TYPE, "application/json") .body(Body::from( - r#"{"url":"https://whatismyip.com/","reason":"check exit IP","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi"}"#, + r#"{"url":"https://fixture-user:fixture-password@whatismyip.com/fixture-path?token=fixture-query","reason":"check exit IP","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi"}"#, )) .unwrap(), ) @@ -1242,6 +1638,17 @@ async fn test_browser_open_returns_forbidden_when_exit_policy_blocks_host() { let message = String::from_utf8(body.to_vec()).unwrap(); assert!(message.contains("whatismyip.com")); assert!(message.contains("direct host networking")); + for private in [ + "fixture-user", + "fixture-password", + "fixture-path", + "fixture-query", + ] { + assert!( + !message.contains(private), + "private URL parts in public error: {message}" + ); + } } #[tokio::test] @@ -1994,9 +2401,16 @@ async fn test_browser_async_open_rejects_second_owner_for_same_browser_instance( .await .unwrap(); assert_eq!( - String::from_utf8(second_body.to_vec()).unwrap(), + std::str::from_utf8(&second_body).unwrap(), "Browser instance already owns an active or in-flight open" ); + let consumer = browser_open_response_consumers(StatusCode::CONFLICT, &second_body); + assert_eq!(consumer["outcome"], serde_json::Value::Null); + assert_eq!(consumer["authority"], false); + assert_eq!( + consumer["evidence"]["admission_reason"], + "instance_open_in_flight" + ); for _ in 0..20 { let auth_state = crate::auth::load_auth_state(dir.path()).unwrap(); @@ -3183,6 +3597,79 @@ async fn test_exact_terminal_vz_settlement_releases_restart_reconciliation_oblig assert!(!dir.path().join("browser-streams").exists()); } +#[tokio::test] +async fn test_browser_space_refusal_preserves_counts_and_cleanup_ownership() { + for (suffix, valid, terminal) in [ + ("", true, true), + ("", true, false), + ("unknown", false, true), + ("counts", false, true), + ] { + let dir = tempfile::tempdir().unwrap(); + write_browser_vz_transport_test_config(dir.path()); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let (state, close_calls, reconciliation_calls) = browser_engine_reconciliation_test_state( + dir.path(), + if terminal { + MockDispatchedBrowserLaunchFailure::TerminalVzSettlement + } else { + MockDispatchedBrowserLaunchFailure::MismatchedTerminalVzSettlement + }, + ) + .await; + let response = gateway_router(state).oneshot( + test_browser_request("localhost:61180", "null").method("POST") + .uri("/api/apps/browser/open").header("x-elastos-home-token", token) + .header(CONTENT_TYPE, "application/json") + .body(Body::from(serde_json::json!({ + "url": format!("https://space-refusal.invalid/{suffix}"), + "reason": "space refusal keeps cleanup ownership", + "display_mode": "webrtc_remote_display", "guarantee_level": "mechanism_microvm", + }).to_string())).unwrap(), + ).await.unwrap(); + assert_eq!( + response.status(), + if valid { + StatusCode::SERVICE_UNAVAILABLE + } else { + StatusCode::INTERNAL_SERVER_ERROR + } + ); + let body = axum::body::to_bytes(response.into_body(), usize::MAX) + .await + .unwrap(); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert!(!String::from_utf8_lossy(&body).contains("private engine diagnostic")); + if valid { + assert_eq!( + payload["refusal"], + serde_json::json!({"code": "insufficient_free_space", "required_bytes": 8589934592_u64, "available_bytes": 8589934591_u64}) + ); + } else { + assert!(payload.get("refusal").is_none()); + } + assert_eq!( + payload["outcome"]["state"], + if terminal { + "terminal_post_effect_cleanup" + } else { + "cleanup_pending" + } + ); + if terminal { + assert_eq!(payload["outcome"]["effects"]["page_acquired"], false); + assert_eq!(payload["outcome"]["effects"]["vm_acquired"], false); + } + assert_eq!(reconciliation_calls.count(), 1); + assert!(close_calls.snapshot().await.is_empty()); + assert_eq!( + browser_launch_reconciliation_obligation_count(dir.path()).await, + usize::from(!terminal) + ); + } +} + #[tokio::test] async fn test_browser_profile_recovery_requires_exact_terminal_settlement() { for (failure, terminal) in [ @@ -3337,6 +3824,51 @@ async fn test_browser_launch_response_loss_reconciles_and_closes_exact_effect() ); } +#[tokio::test] +async fn test_browser_open_preserves_profile_transfer_instruction() { + let dir = tempfile::tempdir().unwrap(); + let authority = passkey_authority(dir.path()); + let token = app_token_for_authority(dir.path(), BROWSER_CAPSULE_ID, &authority); + let state = browser_engine_attached_test_state(dir.path()).await; + let placements = dir + .path() + .join("Runtime/BrowserLifecycle/remote-engine-profiles"); + std::fs::create_dir_all(&placements).unwrap(); + std::fs::write( + placements.join("foreign.json"), + json!({"principal_id": authority.principal_id, "peer": "runtime-b"}).to_string(), + ) + .unwrap(); + let response = gateway_router(state) + .oneshot( + test_browser_request("localhost:61180", "null") + .method("POST") + .uri("/api/apps/browser/open") + .header("x-elastos-home-token", token) + .header(CONTENT_TYPE, "application/json") + .body(Body::from( + r#"{"url":"https://placement.invalid/","display_mode":"webrtc_remote_display","guarantee_level":"operator_rbi"}"#, + )) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR); + let body = axum::body::to_bytes(response.into_body(), 32768) + .await + .unwrap(); + let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert_eq!( + payload["message"], + "This Browser profile requires an approved transfer from its owning Runtime" + ); + assert_eq!(payload["outcome"]["state"], "terminal_pre_effect_failure"); + assert_eq!(payload["outcome"]["effects"]["page_acquired"], false); + assert_eq!(payload["outcome"]["effects"]["vm_acquired"], false); + assert_eq!(payload["outcome"]["effects"]["stream_acquired"], false); + assert_eq!(browser_page_session_count(dir.path()).await, 0); +} + #[tokio::test] async fn test_browser_malformed_success_reconciles_instead_of_releasing_ownership() { let dir = tempfile::tempdir().unwrap(); @@ -3368,6 +3900,12 @@ async fn test_browser_malformed_success_reconciles_instead_of_releasing_ownershi .await .unwrap(); let payload: serde_json::Value = serde_json::from_slice(&body).unwrap(); + assert!(!String::from_utf8_lossy(&body).contains("/private/engine/rootfs.img")); + assert_eq!( + payload["message"], + "Browser Engine failed to start cleanly." + ); + assert_eq!(payload["code"], "provider_error"); assert_eq!(payload["outcome"]["state"], "terminal_post_effect_cleanup"); assert_eq!(close_calls.snapshot().await.len(), 1); assert_eq!(reconciliation_calls.count(), 1); @@ -9749,6 +10287,42 @@ async fn test_browser_operator_inspection_fill_bootstrap_and_detach_scope() { } } +#[tokio::test] +async fn test_browser_open_provider_transport_preserves_remote_cause() { + use crate::api::gateway::gateway_browser::{ + browser_provider_resource_response, browser_provider_resource_result, + BrowserProviderResourceCall, + }; + + let dir = tempfile::tempdir().unwrap(); + let state = browser_engine_attached_test_state(dir.path()).await; + let call = || BrowserProviderResourceCall { + scheme: "browser-engine", + resource: "elastos://browser-engine/launch".to_string(), + request: json!({"op": "launch", "lifecycle_generation": "test-generation"}), + }; + // The real remote-binding validator rejects this missing requester before + // dispatch. Its private cause must survive the adapter's public message. + let failure = browser_provider_resource_result(&state, call()) + .await + .unwrap_err(); + assert_eq!(failure.status, StatusCode::SERVICE_UNAVAILABLE); + let diagnostic = format!("{:#}", failure.diagnostic); + assert!( + diagnostic.contains("Browser requester required"), + "{diagnostic}" + ); + assert!( + diagnostic.contains("Remote Runtime Engine ownership is unavailable"), + "{diagnostic}" + ); + let (status, message) = browser_provider_resource_response(&state, call()) + .await + .unwrap_err(); + assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE); + assert_eq!(message, "Remote Runtime Engine ownership is unavailable"); +} + #[tokio::test] async fn browser_open_repairs_missing_helpers_after_viewer_load() { browser_open_repairs_helpers_after_viewer_load(false, true, None).await; diff --git a/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs b/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs index 073422331..8869514bd 100644 --- a/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs +++ b/elastos/crates/elastos-server/src/api/gateway_tests/support_providers.rs @@ -3943,6 +3943,22 @@ impl Provider for MockReconciliatingBrowserEngineProvider { "launch_settlement_result": settlement, })); } + if request["url"] + .as_str() + .is_some_and(|url| url.contains("space-refusal.invalid")) + { + let mut refusal = json!({"code": "insufficient_free_space", "required_bytes": 8589934592_u64, "available_bytes": 8589934591_u64}); + if request["url"].as_str().unwrap().contains("unknown") { + refusal["code"] = json!("unknown"); + } + if request["url"].as_str().unwrap().contains("counts") { + refusal["available_bytes"] = json!(-1); + } + return Ok(json!({ + "status": "error", "code": "launch_refused", + "message": "private engine diagnostic", "refusal": refusal, + })); + } if matches!( self.failure, MockDispatchedBrowserLaunchFailure::TerminalVzSettlement @@ -3991,6 +4007,12 @@ impl Provider for MockReconciliatingBrowserEngineProvider { "provider": "browser-engine-adapter", "protocol_version": "2.1", "page_id": "unsafe page id", + "direct_network": false, + "wallet_injection": false, + "display_session": { + "schema": "elastos.browser.display-session/v1", + "mode": "/private/engine/rootfs.img", + }, } })), MockDispatchedBrowserLaunchFailure::PendingThenTerminal @@ -4553,9 +4575,7 @@ struct MockBitcoinChallenge { /// capsules/wallet-provider), so a caller holding a newer launch of the same /// session is refused exactly as it is live; the session binding alone would /// let that case through. -fn mock_wallet_authority_binding( - authority: &elastos_wallet_contract::WalletAuthorityV2, -) -> String { +fn mock_wallet_authority_binding(authority: &elastos_wallet_contract::WalletAuthorityV2) -> String { let bytes = serde_json::to_vec(&json!({ "principal_id": authority.principal_id, "session_id": authority.session_id, @@ -6514,8 +6534,12 @@ impl MockWalletProvider { } // The real wallet binds the outcome to the approval's ORIGINAL authority // (validate_chain_outcome_target): a later launch must not attach it. - if approval.get("authority_binding").and_then(|value| value.as_str()) - != request.get("authority_binding").and_then(|value| value.as_str()) + if approval + .get("authority_binding") + .and_then(|value| value.as_str()) + != request + .get("authority_binding") + .and_then(|value| value.as_str()) { return Ok(json!({ "status": "error", diff --git a/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs b/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs index c8459869d..3cde45eb1 100644 --- a/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs +++ b/elastos/crates/elastos-vz/src/bin/browser-vz-engine-supervisor.rs @@ -3280,22 +3280,24 @@ const ROOTFS_OVERLAY_NAME: &str = "rootfs.qcow2"; /// Free space a launch keeps beyond its overlay's worst case (every block of /// the seed rewritten): the room the Home keeps for update staging. -#[cfg(target_os = "linux")] +#[cfg(any(target_os = "linux", test))] const ROOTFS_OVERLAY_FREE_FLOOR: u64 = 4 * 1024 * 1024 * 1024; /// The refusal when this computer cannot hold a launch overlay's worst case /// plus the floor. -#[cfg(target_os = "linux")] +#[cfg(any(target_os = "linux", test))] fn rootfs_overlay_space_refusal(seed_bytes: u64, available: u64) -> Option { let required = seed_bytes.saturating_add(ROOTFS_OVERLAY_FREE_FLOOR); - // Tenths of a GB: the need rounded up, the free space rounded down. - let tenths = |tenths: u64| format!("{}.{}", tenths / 10, tenths % 10); (available < required).then(|| { - format!( - "Browser needs {} GB free on this computer to open; {} GB are free. Free some space, then open Browser again.", - tenths(required.div_ceil(100_000_000)), - tenths(available / 100_000_000) - ) + json!({ + "schema": "elastos.browser.engine.launch-error/v1", + "code": "launch_refused", + "message": "Browser cannot open.", + "refusal": elastos_common::browser_protocol::BrowserLaunchRefusal::InsufficientFreeSpace { + required_bytes: required, + available_bytes: available, + }, + }).to_string() }) } @@ -6074,6 +6076,42 @@ mod tests { VzLaunchOwner::new(VzLaunchIdentity::from_launch(&launch), paths, transport) } + #[tokio::test] + async fn space_refusal_before_vm_start_keeps_first_open_profile_usable() { + let root = tempfile::tempdir().unwrap(); + let mut owner = cleanup_owner_fixture(root.path()); + let disk = root.path().join("BrowserProfiles/default/profile.ext4"); + fs::create_dir_all(disk.parent().unwrap()).unwrap(); + fs::set_permissions(disk.parent().unwrap(), fs::Permissions::from_mode(0o700)).unwrap(); + let request = json!({"profile": { + "schema": "elastos.browser.profile/v1", "scope": "active_principal", + "profile_key": format!("profile-{}", "a".repeat(64)), "disk_path": disk, + "storage": "principal_owned_profile_disk", + "storage_posture": "principal_owned_reset_scoped_unprotected", + "protected_storage": false, "encrypted": false, "recoverable": false, + "recovery": "not_recovery_kit_packaged", "reset": "whole_profile", + "uri": "localhost://Users/0123456789ab/BrowserProfiles/default/profile.ext4", + "public_uri": "localhost://Users/self/BrowserProfiles/default/profile.ext4", + }}); + owner.session_directory = true; + create_owned_launch_paths(&owner.paths, &owner.transport, &mut owner.acquired_paths) + .unwrap(); + owner.profile_disk = Some(prepare_browser_profile_disk(&request).unwrap()); + assert!(owner.profile_disk.as_ref().unwrap().initialize); + let before = fs::metadata(&disk).unwrap(); + let refusal = rootfs_overlay_space_refusal(4 * 1024 * 1024 * 1024, 0).unwrap(); + let settlement: Value = + serde_json::from_str(&owner.finish_cleanup(&refusal, None).await).unwrap(); + assert_eq!(settlement["state"], "terminal_post_effect_cleanup"); + assert_eq!(settlement["effects"]["vm"], false); + let reason: Value = serde_json::from_str(settlement["message"].as_str().unwrap()).unwrap(); + assert_eq!(reason["refusal"]["code"], "insufficient_free_space"); + let reopened = prepare_browser_profile_disk(&request).unwrap(); + assert!(reopened.initialize); + assert_eq!(fs::metadata(&disk).unwrap().ino(), before.ino()); + assert_eq!(fs::metadata(&disk).unwrap().len(), before.len()); + } + #[test] fn native_cleanup_rejects_cached_and_uncertain_vm_states() { assert!(native_vm_absence_proved("Stopped")); @@ -8284,17 +8322,18 @@ mod tests { assert!(other.exists()); } - #[cfg(target_os = "linux")] #[test] fn a_launch_refuses_an_overlay_the_disk_could_not_hold() { // The worst case is every seed block rewritten, plus the update floor. let seed = 4 * 1024 * 1024 * 1024; let required = seed + ROOTFS_OVERLAY_FREE_FLOOR; assert_eq!(rootfs_overlay_space_refusal(seed, required), None); - assert_eq!( - rootfs_overlay_space_refusal(seed, required - 1).as_deref(), - Some("Browser needs 8.6 GB free on this computer to open; 8.5 GB are free. Free some space, then open Browser again.") - ); + let error = rootfs_overlay_space_refusal(seed, required - 1).unwrap(); + let typed: Value = serde_json::from_str(&error).unwrap(); + assert_eq!(typed["schema"], "elastos.browser.engine.launch-error/v1"); + assert_eq!(typed["refusal"]["code"], "insufficient_free_space"); + assert_eq!(typed["refusal"]["required_bytes"], required); + assert_eq!(typed["refusal"]["available_bytes"], required - 1); } #[cfg(not(target_os = "linux"))] diff --git a/scripts/browser-launch-refusal.test.mjs b/scripts/browser-launch-refusal.test.mjs new file mode 100644 index 000000000..1d8a02b2c --- /dev/null +++ b/scripts/browser-launch-refusal.test.mjs @@ -0,0 +1,119 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import http from "node:http"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { spawn } from "node:child_process"; +import { once } from "node:events"; +import { fileURLToPath } from "node:url"; + +const refusal = { code: "insufficient_free_space", required_bytes: 8589934592, available_bytes: 8589934591 }; +const typed = { schema: "elastos.browser.engine.launch-error/v1", code: "launch_refused", message: "Browser cannot open.", refusal }; + +async function controlServiceResponse(t, envelope) { + // Exercise the real supervisor stderr -> control service -> HTTP body path. + const root = fs.mkdtempSync(path.join(os.tmpdir(), "browser-refusal-")); + const socket = path.join(root, "control.sock"); + const launcher = path.join(root, "launcher.mjs"); + fs.writeFileSync(launcher, ` + for await (const chunk of process.stdin) {} // Drain the launch request. + console.error(process.env.TEST_LAUNCH_ERROR); + process.exit(73); + `); + const env = { ...process.env, + TEST_LAUNCH_ERROR: JSON.stringify(envelope), + ELASTOS_BROWSER_VM_CONTROL_SERVICE_CONFIG: JSON.stringify({ + schema: "elastos.browser.vm-control-service.config/v1", + control_socket_path: socket, launcher_program: process.execPath, + launcher_args: [launcher], persistent_launcher: true, + launch_timeout_ms: 3000, shutdown_timeout_ms: 1000, + }), + }; + delete env.ELASTOS_UPDATE_PARENT_PIPE; + const service = spawn(process.execPath, [fileURLToPath(new URL("./browser-vm-control-service.mjs", import.meta.url))], { + env, stdio: ["ignore", "pipe", "pipe"], + }); + let stderr = ""; + service.stderr.on("data", chunk => { stderr = (stderr + chunk).slice(-8192); }); + t.after(async () => { + if (service.exitCode === null && service.signalCode === null) { + const exited = once(service, "exit"); + service.kill("SIGTERM"); + const timer = setTimeout(() => service.kill("SIGKILL"), 3000); + try { await exited; } finally { clearTimeout(timer); } + } + fs.rmSync(root, { recursive: true, force: true }); + }); + await new Promise((resolve, reject) => { + let stdout = ""; + const timer = setTimeout(() => reject(new Error(`control service readiness timed out: ${stderr}`)), 5000); + service.once("error", reject); + service.once("exit", () => { clearTimeout(timer); reject(new Error(`control service exited: ${stderr}`)); }); + service.stdout.on("data", chunk => { + stdout += chunk; + if (stdout.includes('"schema":"elastos.browser.vm-control-service.ready/v1"')) { + clearTimeout(timer); + resolve(); + } + }); + }); + const body = JSON.stringify({ + schema: "elastos.browser.vm-engine.open/v1", + launch_request: { + schema: "elastos.browser.engine.launch-request/v1", + adapter: "browser-vm-product", engine: "chromium_microvm", + url: "https://example.com/", stream_id: "stream:refusal", + lifecycle_generation: "sha256:refusal", target: "tls://example.com:443", + principal_id: "person:local:refusal", network_mode: "runtime_net_only", + direct_network: false, wallet_injection: false, + display_mode: "webrtc_remote_display", guarantee_level: "mechanism_microvm", + }, + requirements: { + substrate: "microvm", display_mode: "webrtc_remote_display", + backend_class: "product_compositor", network_mode: "runtime_net_only", direct_network: false, + }, + }); + return new Promise((resolve, reject) => { + const request = http.request({ socketPath: socket, path: "/pages", method: "POST", + headers: { "content-type": "application/json", "content-length": Buffer.byteLength(body) }, + }, response => { + const chunks = []; + response.on("data", chunk => chunks.push(chunk)); + response.on("error", reject); + response.on("end", () => { + try { resolve({ status: response.statusCode, body: JSON.parse(Buffer.concat(chunks)) }); } + catch (error) { reject(error); } + }); + }); + request.setTimeout(5000, () => request.destroy(new Error("control service response timed out"))); + request.on("error", reject); + request.end(body); + }); +} + +test("control service response carries typed refusal code and counts from supervisor stderr", async t => { + const response = await controlServiceResponse(t, typed); + assert.equal(response.status, 400); + assert.equal(response.body.code, "launch_refused"); + assert.equal(response.body.message, "Browser cannot open."); + assert.deepEqual(response.body.refusal, refusal); +}); + + +for (const [name, bad] of [ + ["unknown code", { ...refusal, code: "unknown" }], + ["string count", { ...refusal, required_bytes: "8589934592" }], + ["unsafe count", { ...refusal, required_bytes: 2 ** 53 }], + ["negative count", { ...refusal, available_bytes: -1 }], + ["equal counts", { ...refusal, available_bytes: refusal.required_bytes }], + ["extra field", { ...refusal, message: "private" }], +]) { + test(`control service response falls back for refusal with ${name}`, async t => { + const response = await controlServiceResponse(t, { ...typed, refusal: bad }); + assert.equal(response.status, 400); + assert.equal(response.body.code, "launch_refused"); + assert.equal(response.body.message, "Browser cannot open."); + assert.equal(response.body.refusal, undefined); + }); +} diff --git a/scripts/browser-vm-control-service.mjs b/scripts/browser-vm-control-service.mjs index f7b1bb6d6..c4b12c185 100755 --- a/scripts/browser-vm-control-service.mjs +++ b/scripts/browser-vm-control-service.mjs @@ -2714,6 +2714,7 @@ function typedLauncherError(parsed) { !exactObjectKeys(parsed, [ "schema", "code", "message", ...(hasSettlement ? ["launch_settlement_result"] : []), + ...(Object.hasOwn(parsed, "refusal") ? ["refusal"] : []), ]) || parsed.schema !== "elastos.browser.engine.launch-error/v1" || typeof parsed.code !== "string" || @@ -2722,6 +2723,7 @@ function typedLauncherError(parsed) { throw new Error("Browser launcher returned an invalid typed launch error"); } const error = codedError(parsed.code, parsed.message); + Object.assign(error, launchRefusalFields(parsed)); if (hasSettlement) { error.vz_launch_settlement = validateVzLaunchSettlement( parsed.launch_settlement_result, @@ -2731,7 +2733,17 @@ function typedLauncherError(parsed) { return error; } -function launcherError(message, stderr) { +export function launchRefusalFields(payload) { + const refusal = payload?.refusal; + if (!exactObjectKeys(refusal, ["code", "required_bytes", "available_bytes"]) || + refusal.code !== "insufficient_free_space" || + !Number.isSafeInteger(refusal.required_bytes) || + !Number.isSafeInteger(refusal.available_bytes) || + refusal.available_bytes < 0 || refusal.available_bytes >= refusal.required_bytes) return {}; + return { refusal: { code: refusal.code, required_bytes: refusal.required_bytes, available_bytes: refusal.available_bytes } }; +} + +export function launcherError(message, stderr) { const detail = String(stderr || "").trim(); if (!detail) return new Error(message); const bounded = detail.length > 8192 ? detail.slice(-8192) : detail; @@ -2747,9 +2759,7 @@ function launcherError(message, stderr) { let error = new Error(settlement.message || message); try { const typed = JSON.parse(settlement.message); - if (exactObjectKeys(typed, ["schema", "code", "message"])) { - error = typedLauncherError(typed); - } + error = typedLauncherError(typed); } catch {} error.vz_launch_settlement = settlement; error.launch_settlement = settlement.state; @@ -4972,6 +4982,7 @@ function main() { ...(typeof error?.code === "string" ? { code: error.code, message } : { error: message }), + ...launchRefusalFields(error), ...(error?.vz_launch_settlement ? { launch_settlement_result: diff --git a/scripts/browser-vm-engine-supervisor.mjs b/scripts/browser-vm-engine-supervisor.mjs index 543c51b7d..f22e5f876 100755 --- a/scripts/browser-vm-engine-supervisor.mjs +++ b/scripts/browser-vm-engine-supervisor.mjs @@ -27,15 +27,16 @@ const INVOCATION_ONLY_VM_ENV = new Set([ ]); class BrowserLaunchError extends Error { - constructor(code, message, launchSettlementResult = undefined) { + constructor(code, message, launchSettlementResult = undefined, refusal = undefined) { super(message); this.code = code; this.launch_settlement_result = launchSettlementResult; + this.refusal = refusal; } } -function launchError(code, message, launchSettlementResult = undefined) { - return new BrowserLaunchError(code, message, launchSettlementResult); +function launchError(code, message, launchSettlementResult = undefined, refusal = undefined) { + return new BrowserLaunchError(code, message, launchSettlementResult, refusal); } function fail(error) { @@ -45,6 +46,7 @@ function fail(error) { schema: "elastos.browser.engine.launch-error/v1", code: error.code, message, + ...(error.refusal === undefined ? {} : { refusal: error.refusal }), ...(error.launch_settlement_result === undefined ? {} : { launch_settlement_result: error.launch_settlement_result }), @@ -473,7 +475,7 @@ function collectPreflight({ dataDir, platform }) { }; } -function postJsonOverUnix(socketPath, requestPath, body, timeoutMs) { +export function postJsonOverUnix(socketPath, requestPath, body, timeoutMs) { validateAbsolutePath(socketPath, CONTROL_SOCKET_ENV); const bytes = Buffer.from(JSON.stringify(body)); return new Promise((resolve, reject) => { @@ -507,6 +509,7 @@ function postJsonOverUnix(socketPath, requestPath, body, timeoutMs) { parsed.code || "engine_process_unavailable", parsed.message || parsed.error || `Browser VM control returned ${response.statusCode}`, parsed.launch_settlement_result, + parsed.refusal, ) : new Error(parsed.error || parsed.message || `Browser VM control returned ${response.statusCode}`), );