Skip to content

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.html
index 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.zig
index 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.zig
index 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.Promis
if (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 Executi
transfer.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;