Lightpanda: the headless browser designed for AI and automation
http: Guarantee Transfer contract of single outcome callback
Karl Seguina6618fff6334
diff --git a/src/network/HttpClient.zig b/src/network/HttpClient.zigindex 9a90c1086..cf7bdaf53 100644--- a/src/network/HttpClient.zig+++ b/src/network/HttpClient.zig@@ -2055,6 +2055,9 @@ pub const Transfer = struct {_notified_fail: bool = false,+ // guard to ensure only one of done/error/shutdown is ever called+ _outcome_delivered: bool = false,+// Set when conn is temporarily detached from transfer during redirect// reconfiguration. Used by processMessages to release the orphaned conn// if reconfiguration fails. Transient inside the redirect path only.@@ -2150,9 +2153,9 @@ pub const Transfer = struct {// responsible for resuming or terminating it.parked: ParkedBy,- // detachInDelivery ran; user callbacks are noop'd, owner link is- // cleared, deliver() will deinit when its loop exits. `_conn`- // (if any) is what `deinit` will release.+ // detachInDelivery ran; delivery callbacks are noop'd, owner link+ // is cleared, deliver() will finishDelivery when its loop exits.+ // `_conn` (if any) is what `deinit` will release.aborted,};@@ -2379,8 +2382,14 @@ pub const Transfer = struct {.err = error.Shutdown,});}- self.req.shutdown_callback(self.req.ctx);- self.detachOrDeinit();+ switch (self.state) {+ .delivering => self.detachInDelivery(),+ .aborted => {}, // already detached+ else => {+ self.req.shutdown_callback(self.req.ctx);+ self.deinit();+ },+ }}// Decide whether to tear down now or defer.@@ -2409,8 +2418,9 @@ pub const Transfer = struct {// the next event (and, for a streaming transfer whose conn is// still in the multi, so a nested pump's completion path// short-circuits),- // - noop every user callback so a nested pump draining the still-- // inflight response can't re-enter user code,+ // - noop every delivery callback so a nested pump draining the still-+ // inflight response can't re-enter user code. shutdown_callback is+ // kept: only kill() calls it.// - unlink from owner.transfers and clear `owner` so the owning// Frame/WGS can be freed while this transfer is still draining.// transfer.deinit (called by deliver() on exit) sees@@ -2421,7 +2431,6 @@ pub const Transfer = struct {// releases it once libcurl is done.self.state = .aborted;self.req.start_callback = null;- self.req.shutdown_callback = noopShutdown;self.req.header_callback = Noop.headerCallback;self.req.data_callback = Noop.dataCallback;self.req.done_callback = Noop.doneCallback;@@ -2439,6 +2448,10 @@ pub const Transfer = struct {if (self._notified_fail) {return;}++ if (self.state == .aborted) {+ return;+ }self._notified_fail = true;if (!self.req.internal) {@@ -2453,6 +2466,7 @@ pub const Transfer = struct {});}+ self._outcome_delivered = true;self.req.error_callback(self.req.ctx, err);}@@ -2461,7 +2475,7 @@ pub const Transfer = struct {fn failDelivery(self: *Transfer, err: anyerror) void {log.err(.http, "delivery callback", .{ .err = err, .req = self });self.requestFailed(err);- self.deinit();+ self.finishDelivery();}// Fail the transfer asynchronously: the error is buffered and@@ -3272,6 +3286,7 @@ pub const Transfer = struct {.content_length = transfer._content_length,});}+ transfer._outcome_delivered = true;req.done_callback(req.ctx) catch |err| {return transfer.failDelivery(err);};@@ -3285,7 +3300,7 @@ pub const Transfer = struct {}if (transfer.state == .aborted or terminal) {- transfer.deinit();+ transfer.finishDelivery();return;}@@ -3293,6 +3308,15 @@ pub const Transfer = struct {transfer._events.clearRetainingCapacity();transfer.state = .inflight;}++ fn finishDelivery(self: *Transfer) void {+ if (self.state == .aborted and self._outcome_delivered == false) {+ // the transfer is aborted and hasn't had a done/error/shutdown+ // callback called yet.+ self.req.shutdown_callback(self.req.ctx);+ }+ self.deinit();+ }};// Response-state owned by this transfer's currently-in-flight response.@@ -3886,6 +3910,171 @@ test "HttpClient: fulfillIntercepted survives a done_callback that tears down thtry testing.expectEqual(null, owner.transfers.first);}+test "HttpClient: kill during done_callback does not also fire shutdown_callback" {+ var pool = ArenaPool.init(testing.allocator, .{});+ defer pool.deinit();++ var client: Client = undefined;+ initTestClient(&client, &pool);+ // Runs before pool.deinit (LIFO): retired arenas must go back first.+ defer client.processGraveyard();+ defer client.transfers.deinit(testing.allocator);++ var owner: Owner = .init(undefined, undefined);++ const Ctx = struct {+ client: *Client,+ owner: *Owner,+ in_done: bool = false,+ done_called: bool = false,+ shutdown_called: bool = false,+ shutdown_during_done: bool = false,++ fn doneCallback(ctx: *anyopaque) !void {+ const self: *@This() = @ptrCast(@alignCast(ctx));+ self.done_called = true;+ self.in_done = true;+ defer self.in_done = false;+ // Navigation / page-close kicked off by JS inside done_callback.+ self.client.abortOwner(self.owner);+ }++ fn shutdownCallback(ctx: *anyopaque) void {+ const self: *@This() = @ptrCast(@alignCast(ctx));+ self.shutdown_called = true;+ self.shutdown_during_done = self.in_done;+ }+ };+ var ctx = Ctx{ .client = &client, .owner = &owner };++ const arena = try pool.acquire(.small, "test");+ const transfer = try arena.create(Transfer);+ transfer.* = .{+ .arena = arena,+ .owner = null,+ .req = .{+ .frame_id = 0,+ .loader_id = 0,+ .method = .GET,+ .url = "http://example.com/",+ .cookie_jar = null,+ .cookie_origin = "",+ .resource_type = .xhr,+ .notification = undefined,+ .shutdown_callback = Ctx.shutdownCallback,+ .ctx = &ctx,+ .done_callback = Ctx.doneCallback,+ },+ .client = &client,+ .id = 1,+ .start_time = 0,+ };++ try client.transfers.putNoClobber(testing.allocator, transfer.id, transfer);+ owner.addTransfer(transfer);+ transfer.owner = &owner;++ transfer.park(.intercept_request);+ client.intercepted += 1;+ try client.fulfillIntercepted(transfer, 200, &.{}, "hello");+ _ = client.dispatchCompleted(.all);++ try testing.expect(ctx.done_called);+ try testing.expectEqual(false, ctx.shutdown_during_done);+ try testing.expectEqual(false, ctx.shutdown_called);++ // Freed exactly once regardless.+ try testing.expectEqual(0, client.intercepted);+ try testing.expectEqual(0, client.transfers.count());+ try testing.expectEqual(null, owner.transfers.first);+}++test "HttpClient: kill during a non-terminal callback defers shutdown_callback" {+ // Same re-entrant kill, but from header_callback: the consumer has had no+ // outcome yet, so it must still get shutdown — once, and only after its+ // callback has returned. done_callback must not run on top of it.+ var pool = ArenaPool.init(testing.allocator, .{});+ defer pool.deinit();++ var client: Client = undefined;+ initTestClient(&client, &pool);+ // Runs before pool.deinit (LIFO): retired arenas must go back first.+ defer client.processGraveyard();+ defer client.transfers.deinit(testing.allocator);++ var owner: Owner = .init(undefined, undefined);++ const Ctx = struct {+ client: *Client,+ owner: *Owner,+ in_header: bool = false,+ done_called: bool = false,+ shutdown_calls: u8 = 0,+ shutdown_during_header: bool = false,++ fn headerCallback(transfer: *Transfer) !Transfer.HeaderResult {+ const self: *@This() = @ptrCast(@alignCast(transfer.req.ctx));+ self.in_header = true;+ defer self.in_header = false;+ self.client.abortOwner(self.owner);+ return .proceed;+ }++ fn doneCallback(ctx: *anyopaque) !void {+ const self: *@This() = @ptrCast(@alignCast(ctx));+ self.done_called = true;+ }++ fn shutdownCallback(ctx: *anyopaque) void {+ const self: *@This() = @ptrCast(@alignCast(ctx));+ self.shutdown_calls += 1;+ self.shutdown_during_header = self.in_header;+ }+ };+ var ctx = Ctx{ .client = &client, .owner = &owner };++ const arena = try pool.acquire(.small, "test");+ const transfer = try arena.create(Transfer);+ transfer.* = .{+ .arena = arena,+ .owner = null,+ .req = .{+ .frame_id = 0,+ .loader_id = 0,+ .method = .GET,+ .url = "http://example.com/",+ .cookie_jar = null,+ .cookie_origin = "",+ .resource_type = .xhr,+ .notification = undefined,+ .shutdown_callback = Ctx.shutdownCallback,+ .ctx = &ctx,+ .header_callback = Ctx.headerCallback,+ .done_callback = Ctx.doneCallback,+ },+ .client = &client,+ .id = 1,+ .start_time = 0,+ };++ try client.transfers.putNoClobber(testing.allocator, transfer.id, transfer);+ owner.addTransfer(transfer);+ transfer.owner = &owner;++ transfer.park(.intercept_request);+ client.intercepted += 1;+ try client.fulfillIntercepted(transfer, 200, &.{}, "hello");+ _ = client.dispatchCompleted(.all);++ try testing.expectEqual(1, ctx.shutdown_calls);+ try testing.expectEqual(false, ctx.shutdown_during_header);+ try testing.expectEqual(false, ctx.done_called);++ try testing.expectEqual(0, client.intercepted);+ try testing.expectEqual(0, client.transfers.count());+ try testing.expectEqual(null, owner.transfers.first);+}+test "HttpClient: aborting a robots-parked transfer unlinks it from the gate" {// Regression: RobotsGate's single-flight map kept a raw *Transfer with// nothing removing it when a parked transfer was aborted out-of-band