Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(streams): disturb the source when piping starts

ldm0c019abeeb176
diff --git a/moli-core/tests/fixtures/runtime/pipe_disturbed.js b/moli-core/tests/fixtures/runtime/pipe_disturbed.js
new file mode 100644
index 000000000..097f7023a
--- /dev/null
+++ b/moli-core/tests/fixtures/runtime/pipe_disturbed.js
@@ -0,0 +1,86 @@
+async function runPipeDisturbedProbe(scenario) {
+ const errors = [];
+ const check = (condition, label) => {
+ if (!condition) errors.push(label);
+ };
+ for (const byteStream of [false, true]) {
+ for (const method of ['pipeTo', 'pipeThrough']) {
+ const cases = scenario === 'start'
+ ? ['backpressure', 'pre-aborted', 'source-closed', 'source-errored', 'sink-closed', 'sink-errored']
+ : ['source-locked', 'sink-locked', 'invalid-sink', 'invalid-signal', 'throwing-options'];
+ for (const state of cases) {
+ const label = `${byteStream ? 'bytes' : 'default'}/${method}/${state}`;
+ const reason = new Error(label);
+ let sourceController, sinkController, pulls = 0, writes = 0;
+ const source = new ReadableStream({
+ ...(byteStream ? {type: 'bytes'} : {}),
+ start(controller) { sourceController = controller; },
+ pull() { ++pulls; }
+ }, {highWaterMark: 0});
+ const body = new Response(source);
+ check(body.body === source, `${label}: body observes the tested source`);
+ const sink = new WritableStream({
+ start(controller) { sinkController = controller; },
+ write() { ++writes; },
+ abort() { check(body.bodyUsed, `${label}: abort observes disturbed source`); }
+ }, {highWaterMark: 0});
+ const output = new ReadableStream({}, {highWaterMark: 0});
+ const outputBody = new Response(output);
+ const abort = new AbortController();
+ let options = {signal: abort.signal, preventCancel: true};
+ let destination = sink, reader, writer;
+ if (state === 'source-closed') sourceController.close();
+ if (state === 'source-errored') sourceController.error(reason);
+ if (state === 'sink-closed') await sink.close();
+ if (state === 'sink-errored') sinkController.error(reason);
+ if (state === 'pre-aborted') abort.abort(reason);
+ if (state === 'source-locked') reader = source.getReader();
+ if (state === 'sink-locked') writer = sink.getWriter();
+ if (state === 'invalid-sink') destination = {};
+ if (state === 'invalid-signal') options = {signal: {}};
+ if (state === 'throwing-options') options = {get preventCancel() {throw reason;}};
+ check(!body.bodyUsed, `${label}: initially undisturbed`);
+ let completion, thrown;
+ try {
+ if (method === 'pipeTo') {
+ completion = source.pipeTo(destination, options);
+ completion.catch(() => {});
+ } else {
+ const result = source.pipeThrough({readable: output, writable: destination}, options);
+ check(result === output, `${label}: returns output stream`);
+ }
+ } catch (error) {
+ thrown = error;
+ }
+ if (scenario === 'start') {
+ check(thrown === undefined, `${label}: accepted pipe does not throw`);
+ check(body.bodyUsed, `${label}: synchronously disturbed without reading`);
+ check(pulls === 0 && writes === 0, `${label}: no pull or write before return`);
+ check(!outputBody.bodyUsed, `${label}: output remains undisturbed`);
+ abort.abort(reason);
+ if (completion) await completion.catch(() => {});
+ for (let turn = 0; (source.locked || sink.locked) && turn < 30; ++turn) {
+ await new Promise(resolve => setTimeout(resolve, 0));
+ }
+ check(!source.locked && !sink.locked, `${label}: pipe releases locks`);
+ check(body.bodyUsed, `${label}: remains disturbed after shutdown`);
+ } else {
+ if (completion) {
+ check(thrown === undefined, `${label}: pipeTo returns a rejection`);
+ thrown = await completion.then(() => undefined, error => error);
+ }
+ check(state === 'throwing-options' ? thrown === reason : thrown instanceof TypeError,
+ `${label}: validation rejects with original error`);
+ reader?.releaseLock();
+ writer?.releaseLock();
+ check(!body.bodyUsed, `${label}: rejected pipe leaves source undisturbed`);
+ check(!source.locked && !sink.locked, `${label}: rejected pipe acquires no locks`);
+ check(pulls === 0 && writes === 0, `${label}: rejected pipe does not read or write`);
+ }
+ // Avoid invoking the observation above during test cleanup.
+ await Promise.allSettled([source.cancel(), output.cancel()]);
+ }
+ }
+ }
+ return {errors};
+}
diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rs
index bad02af1b..f67629c7d 100644
--- a/moli-core/tests/web_apis.rs
+++ b/moli-core/tests/web_apis.rs
@@ -1,3 +1,6 @@
+#[path = "web_apis/pipe_disturbed.rs"]
+mod pipe_disturbed;
+
use moli_test_support as support;
use anyhow::Result;
diff --git a/moli-core/tests/web_apis/pipe_disturbed.rs b/moli-core/tests/web_apis/pipe_disturbed.rs
new file mode 100644
index 000000000..93f4e51fc
--- /dev/null
+++ b/moli-core/tests/web_apis/pipe_disturbed.rs
@@ -0,0 +1,91 @@
+use super::*;
+
+async fn assert_pipe_disturbed(scenario: &str) -> Result<()> {
+ let server = FixtureServer::spawn().await?;
+ let browser = Browser::new(AppConfig::default())?;
+ let source = format!(
+ "{}\nrunPipeDisturbedProbe({}).then(finish, error => finish({{error: String(error)}}));",
+ include_str!("../fixtures/runtime/pipe_disturbed.js"),
+ serde_json::to_string(scenario)?,
+ );
+ for target in ["window", "child", "worker"] {
+ let observed = tokio::time::timeout(
+ Duration::from_secs(20),
+ run_probe(&browser, &server, target, &source),
+ )
+ .await??;
+ assert_eq!(
+ observed,
+ serde_json::json!({"errors": []}),
+ "{scenario}/{target}"
+ );
+ }
+ server.shutdown().await;
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn piping_disturbs_fetch_bodies_before_reads_and_abort_handling() -> Result<()> {
+ assert_pipe_disturbed("start").await
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn rejected_piping_preserves_undisturbed_fetch_bodies() -> Result<()> {
+ assert_pipe_disturbed("reject").await
+}
+
+fn markup_url(server: &FixtureServer, markup: &str) -> String {
+ let mut url = url::Url::parse(&server.url("/compat/child-dynamic-markup-document")).unwrap();
+ url.query_pairs_mut().append_pair("markup", markup);
+ url.into()
+}
+
+async fn run_probe(
+ browser: &Browser,
+ server: &FixtureServer,
+ target: &str,
+ source: &str,
+) -> Result<serde_json::Value> {
+ let markup = if target == "worker" {
+ let source = serde_json::to_string(&format!(
+ "self.finish = value => postMessage(value);\n{source}"
+ ))?;
+ format!(
+ r#"<!doctype html><script>
+ const worker = new Worker(URL.createObjectURL(new Blob([{source}], {{type: 'text/javascript'}})));
+ window.done = new Promise(resolve => {{
+ worker.onmessage = event => {{ resolve(event.data); worker.terminate(); }};
+ }});
+ worker.postMessage('go');
+ </script>"#
+ )
+ } else {
+ format!(
+ "<!doctype html><script>self.done = new Promise(resolve => self.finish = resolve);\n{source}</script>"
+ )
+ };
+ let url = markup_url(server, &markup);
+ let url = if target == "child" {
+ markup_url(
+ server,
+ &format!(
+ "<!doctype html><iframe id=target src=\"{}\"></iframe>",
+ url.replace('&', "&amp;")
+ ),
+ )
+ } else {
+ url
+ };
+ let mut page = browser.fetch(&url).await?;
+ let expression = if target == "child" {
+ "document.getElementById('target').contentWindow.done.then(JSON.stringify)"
+ } else {
+ "done.then(JSON.stringify)"
+ };
+ let value = page
+ .evaluate_runtime_expression_with_await_async(expression, true)
+ .await?;
+ Ok(serde_json::from_str(
+ value["value"].as_str().expect("callback probe result"),
+ )?)
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/streams/readable.rs b/moli-renderer-v8/src/context_bootstrap/streams/readable.rs
index b676d6963..866edf2f8 100644
--- a/moli-renderer-v8/src/context_bootstrap/streams/readable.rs
+++ b/moli-renderer-v8/src/context_bootstrap/streams/readable.rs
@@ -1,6 +1,6 @@
use super::super::stream_adapter::{
- TeeStartError, apply_readable_stream_access_transition, enqueue_byte_chunk,
- install_readable_stream_pipe_to_abort_signal, lock_readable_stream,
+ TeeStartError, apply_readable_stream_access_transition, disturb_readable_stream,
+ enqueue_byte_chunk, install_readable_stream_pipe_to_abort_signal, lock_readable_stream,
new_lazy_readable_byte_stream_object, new_readable_byte_stream_object,
new_readable_stream_pipe_owner, prime_readable_stream_pipe_to, readable_stream_access_snapshot,
register_readable_stream_pipe_owner, register_writable_stream_pipe_owner,
@@ -414,6 +414,9 @@ fn start_readable_stream_pipe_to<'s>(
}
set_writable_stream_locked(scope, writable, true);
register_writable_stream_pipe_owner(scope, writable, owner);
+ // ReadableStreamPipeTo disturbs the source before handling aborts or
+ // waiting for destination backpressure to permit the first read.
+ disturb_readable_stream(scope, stream);
if let Some(signal) = options.signal {
install_readable_stream_pipe_to_abort_signal(scope, stream, signal);
}