Lightpanda: the headless browser designed for AI and automation
webapi: abort signal aborts a fetch
Karl Seguind7a58943a9e0
diff --git a/src/browser/tests/net/fetch.html b/src/browser/tests/net/fetch.htmlindex a0d7990ef..2274cc1f9 100644--- a/src/browser/tests/net/fetch.html+++ b/src/browser/tests/net/fetch.html@@ -315,6 +315,60 @@}</script>+<script id=abort_reasons type=module>+ {+ const state = await testing.async();++ async function rejection(promise) {+ try {+ await promise;+ return 'resolved';+ } catch (e) {+ return e;+ }+ }++ // /xhr/slow takes 100ms: the abort must not wait for it+ const c1 = new AbortController();+ setTimeout(() => c1.abort(), 10);+ const start = Date.now();+ const inflight = await rejection(fetch('http://127.0.0.1:9582/xhr/slow', { signal: c1.signal }));+ const elapsed = Date.now() - start;++ const c2 = new AbortController();+ const custom = new Error('mine');+ setTimeout(() => c2.abort(custom), 10);+ const custom_reason = await rejection(fetch('http://127.0.0.1:9582/xhr/slow', { signal: c2.signal }));++ const timeout = await rejection(fetch('http://127.0.0.1:9582/xhr/slow', { signal: AbortSignal.timeout(10) }));++ const c3 = new AbortController();+ setTimeout(() => c3.abort('any'), 10);+ const any = await rejection(fetch('http://127.0.0.1:9582/xhr/slow', {+ signal: AbortSignal.any([new AbortController().signal, c3.signal]),+ }));++ const pre_aborted = await rejection(fetch('http://127.0.0.1:9582/xhr', { signal: AbortSignal.abort(custom) }));++ // a completed fetch must detach from its signal+ const c4 = new AbortController();+ const response = await fetch('http://127.0.0.1:9582/xhr', { signal: c4.signal });+ c4.abort();+ const text = await response.text();++ state.resolve();+ await state.done(() => {+ testing.expectEqual('AbortError', inflight.name);+ testing.expectTrue(elapsed < 100, 'abort waited for the response: ' + elapsed);+ testing.expectEqual(custom, custom_reason);+ testing.expectEqual('TimeoutError', timeout.name);+ testing.expectEqual('any', any);+ testing.expectEqual(custom, pre_aborted);+ testing.expectEqual(100, text.length);+ });+ }+</script>+<script id=fetch_in_worker type=module>{const state = await testing.async();diff --git a/src/browser/webapi/AbortSignal.zig b/src/browser/webapi/AbortSignal.zigindex 9adf1effc..f15eb9742 100644--- a/src/browser/webapi/AbortSignal.zig+++ b/src/browser/webapi/AbortSignal.zig@@ -21,6 +21,8 @@ const lp = @import("lightpanda");const js = @import("../js/js.zig");+const Fetch = @import("net/Fetch.zig");+const Event = @import("Event.zig");const Scheduler = @import("Scheduler.zig");const EventTarget = @import("EventTarget.zig");@@ -40,6 +42,7 @@ const Dependend = union(enum) {// Handled by the owning signal's markAborted (which runs for dependent// signals too, unlike this union's markAborted).scheduler_task: *Scheduler.Task,+ fetch: *Fetch, // The fetch removes itself when it completes.// Returns false if the dependent was already aborted, in which case no// abort event must be dispatched for it.@@ -54,14 +57,14 @@ const Dependend = union(enum) {try dep.markAborted(exec);return true;},- .scheduler_task => return false,+ .scheduler_task, .fetch => return false,}}fn dispatchAbortEvent(self: Dependend, exec: *const Execution) !void {switch (self) {.signal => |dep| try dep.dispatchAbortEvent(exec),- .model_context_tool, .scheduler_task => {},+ .model_context_tool, .scheduler_task, .fetch => {},}}};@@ -149,15 +152,25 @@ fn markAborted(self: *AbortSignal, reason_: ?Reason, exec: *const Execution) !vo}// Unlike the loop in abort(), this runs for dependent signals too, so a- // task registered on an any() signal still gets rejected.+ // task or fetch registered on an any() signal still gets rejected.for (self._dependents.items) |dep| {switch (dep) {.scheduler_task => |task| task.onAbort(self._reason, exec),+ .fetch => |fetch| fetch.abort(self._reason),else => {},}}}+pub fn removeDependent(self: *AbortSignal, dep: Dependend) void {+ for (self._dependents.items, 0..) |d, i| {+ if (std.meta.eql(d, dep)) {+ _ = self._dependents.orderedRemove(i);+ return;+ }+ }+}+fn dispatchAbortEvent(self: *AbortSignal, exec: *const Execution) !void {const target = self.asEventTarget();const on_abort = self._on_abort;diff --git a/src/browser/webapi/net/Fetch.zig b/src/browser/webapi/net/Fetch.zigindex e04a7c60c..1f38413c6 100644--- a/src/browser/webapi/net/Fetch.zig+++ b/src/browser/webapi/net/Fetch.zig@@ -24,7 +24,6 @@ const URL = @import("../../URL.zig");const HttpClient = @import("../../../network/HttpClient.zig");const AbortSignal = @import("../AbortSignal.zig");-const DOMException = @import("../DOMException.zig");const Request = @import("Request.zig");const Response = @import("Response.zig");@@ -43,6 +42,7 @@ _buf: std.ArrayList(u8),_response: *Response,_owns_response: bool,_signal: ?*AbortSignal,+_abort_reason: ?AbortSignal.Reason = null,_manual_redirect: bool,_no_cors: bool,_null_body: bool,@@ -94,7 +94,7 @@ pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promisif (request._signal) |signal| {if (signal._aborted) {- resolver.reject("fetch aborted", DOMException.init("The operation was aborted.", "AbortError"));+ resolver.reject("fetch aborted", try AbortSignal.reasonJsValue(signal._reason, exec.js.local.?));return resolver.promise();}}@@ -192,6 +192,10 @@ fn submit(request: *Request, body: ?[]const u8, sink: Sink, exec: *const Executitransfer.req.referrer_policy = policy;}}++ if (fetch._signal) |signal| {+ try signal._dependents.append(exec.arena, .{ .fetch = fetch });+ }}// Held for Response.deinit's abort; the error, shutdown and done@@ -209,12 +213,6 @@ fn httpHeaderDoneCallback(transfer: *Transfer) !Transfer.HeaderResult {const self: *Fetch = @ptrCast(@alignCast(transfer.req.ctx));const is_opaque = self._no_cors and transfer.client.obey_cors and transfer._cors_cross_origin;- if (self._signal) |signal| {- if (signal._aborted) {- return error.TransferCanceled;- }- }-const status = transfer.responseStatus().?;if (is_opaque or Response.isNullBodyStatus(status) or (self._manual_redirect and HttpClient.isRedirectStatus(status))) {self._null_body = true;@@ -297,13 +295,6 @@ fn httpHeaderDoneCallback(transfer: *Transfer) !Transfer.HeaderResult {fn httpDataCallback(transfer: *Transfer, data: []const u8) !void {const self: *Fetch = @ptrCast(@alignCast(transfer.req.ctx));- // Check if aborted- if (self._signal) |signal| {- if (signal._aborted) {- return error.TransferCanceled;- }- }-if (self._null_body) {return;}@@ -313,6 +304,8 @@ fn httpDataCallback(transfer: *Transfer, data: []const u8) !void {fn httpDoneCallback(ctx: *anyopaque) !void {const self: *Fetch = @ptrCast(@alignCast(ctx));+ self.detachSignal();+var response = self._response;response._http_transfer = null;response._body = if (self._null_body) .empty else .{ .bytes = self._buf.items };@@ -345,6 +338,7 @@ fn httpDoneCallback(ctx: *anyopaque) !void {fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {const self: *Fetch = @ptrCast(@alignCast(ctx));+ self.detachSignal();log.info(.http, "request error", .{.source = "fetch",@@ -378,7 +372,13 @@ fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {self._exec.js.localScope(&ls);defer ls.deinit();- if (owns_response and self._headers_done and self.isAborted() == false) {+ if (self._abort_reason) |reason| {+ if (AbortSignal.reasonJsValue(reason, &ls.local)) |js_val| {+ return ls.toLocal(resolver).reject("fetch aborted", js_val);+ } else |_| {}+ }++ if (owns_response and self._headers_done) {// Once we have the headers, the promise should resolve. A later error,// like libcurl returning a BadContentEncoding errors at the body, not// the fetch.@@ -396,13 +396,26 @@ fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {ls.toLocal(resolver).rejectError("fetch error", .{ .type_error = "fetch error" });}-fn isAborted(self: *const Fetch) bool {- const signal = self._signal orelse return false;- return signal._aborted;+// Called by _signal when it aborts. Synchronously fires httpErrorCallback+// which frees self.+pub fn abort(self: *Fetch, reason: AbortSignal.Reason) void {+ // detach first so we don't try to remove ourselves from the signal, the+ // signal will take care of that.+ self._signal = null;+ self._abort_reason = reason;+ const transfer = self._response._http_transfer orelse return;+ transfer.cancel();+}++fn detachSignal(self: *Fetch) void {+ const signal = self._signal orelse return;+ self._signal = null;+ signal.removeDependent(.{ .fetch = self });}fn httpShutdownCallback(ctx: *anyopaque) void {const self: *Fetch = @ptrCast(@alignCast(ctx));+ self.detachSignal();if (self._owns_response) {const sink = self._sink;