Skip to content

Lightpanda: the headless browser designed for AI and automation

idb: handle requeue index order and abort in settle

Karl Seguincb8d6d927050
diff --git a/src/browser/tests/indexeddb.html b/src/browser/tests/indexeddb.html
index 8fb02c003..fe9e9b0e5 100644
--- a/src/browser/tests/indexeddb.html
+++ b/src/browser/tests/indexeddb.html
@@ -997,6 +997,29 @@
}
</script>
+<!-- A request's success handler may abort() its own transaction mid-delivery.
+ settle() must not then commit/rollback the already-rolled-back transaction, and
+ the write must not persist. -->
+<script id="abort_in_success_handler" type=module>
+{
+ const state = await testing.async();
+ const open = indexedDB.open("abort-handler-db", 1);
+ open.onupgradeneeded = (e) => e.target.result.createObjectStore("s").add("v1", "k");
+ open.onsuccess = (e) => {
+ const db = e.target.result;
+ const tx = db.transaction("s", "readwrite");
+ const req = tx.objectStore("s").put("v2", "k");
+ req.onsuccess = () => tx.abort();
+ tx.onabort = () => {
+ const g = db.transaction("s", "readonly").objectStore("s").get("k");
+ g.onsuccess = () => state.resolve(g.result);
+ };
+ };
+ // The put was rolled back by the abort, so "k" keeps its original value.
+ await state.done((value) => testing.expectEqual("v1", value));
+}
+</script>
+
<!-- After commit(), the transaction is "committing": abort() must throw
InvalidStateError (commit wins), and the writes still land. -->
<script id="commit_then_abort" type=module>
@@ -1025,6 +1048,31 @@
}
</script>
+<!-- Calling commit() inside upgradeneeded settles the versionchange transaction;
+ the open path must not settle it a second time. The upgrade still persists and
+ the open still succeeds. -->
+<script id="commit_in_upgradeneeded" type=module>
+{
+ const state = await testing.async();
+ const open = indexedDB.open("commit-upgrade-db", 1);
+ open.onupgradeneeded = (e) => {
+ const db = e.target.result;
+ db.createObjectStore("s").add("v", "k");
+ e.target.transaction.commit();
+ };
+ open.onsuccess = (e) => {
+ const db = e.target.result;
+ const g = db.transaction("s", "readonly").objectStore("s").get("k");
+ g.onsuccess = () => state.resolve({ version: db.version, value: g.result });
+ };
+ open.onerror = () => state.resolve({ err: open.error && open.error.name });
+ await state.done((got) => {
+ testing.expectEqual(1, got.version);
+ testing.expectEqual("v", got.value);
+ });
+}
+</script>
+
<!-- getAllRecords + the IDBGetAllOptions dictionary (query/count/direction),
returning IDBRecord {key, primaryKey, value}. Also checks the dictionary
overload of getAll/getAllKeys, and that commit() delivers asynchronously (the
diff --git a/src/browser/webapi/storage/idb/IDBFactory.zig b/src/browser/webapi/storage/idb/IDBFactory.zig
index a2d527244..4e4968be0 100644
--- a/src/browser/webapi/storage/idb/IDBFactory.zig
+++ b/src/browser/webapi/storage/idb/IDBFactory.zig
@@ -118,7 +118,11 @@ const OpenContext = struct {
// it's exposed as `request.transaction` and committed here once the
// handler returns.
try engine.begin();
- errdefer engine.rollback();
+
+ var closed = false;
+ errdefer if (closed == false) {
+ engine.rollback();
+ };
const database_id = try engine.upsertDatabase(self.name, requested);
const db = try IDBDatabase.init(exec, engine, database_id, self.name, requested);
@@ -135,13 +139,16 @@ const OpenContext = struct {
}
if (txn.aborted()) {
- // updateneeded handler called abort() (what a jerk!)
+ // updateneeded handler called abort() (what a jerk!) — abort() already
+ // rolled back.
+ closed = true;
self.request._txn = null;
self.request.setError(error.AbortError);
return self.request.deliver(exec);
}
txn.settle(exec);
+ closed = true;
self.request._txn = null;
return self.request.fireSuccess(exec);
}
diff --git a/src/browser/webapi/storage/idb/IDBObjectStore.zig b/src/browser/webapi/storage/idb/IDBObjectStore.zig
index 25f29fa69..74cd93f31 100644
--- a/src/browser/webapi/storage/idb/IDBObjectStore.zig
+++ b/src/browser/webapi/storage/idb/IDBObjectStore.zig
@@ -335,7 +335,9 @@ fn write(self: *IDBObjectStore, value: js.Value, key_arg: ?js.Value, kind: Write
pub fn runWrite(self: *IDBObjectStore, request: *IDBRequest, kind: WriteKind, value_global: js.Value.Global, prepared: PreparedKey, exec: *Execution) !void {
self.writeInner(request, kind, value_global, prepared, exec) catch |err| {
- log.warn(.storage, "idb write", .{ .err = err, .kind = kind });
+ if (err != error.Constraint) {
+ log.warn(.storage, "idb write", .{ .err = err, .kind = kind });
+ }
request.setError(err);
};
}
diff --git a/src/browser/webapi/storage/idb/IDBRequest.zig b/src/browser/webapi/storage/idb/IDBRequest.zig
index 1b90fe035..b6ba7d788 100644
--- a/src/browser/webapi/storage/idb/IDBRequest.zig
+++ b/src/browser/webapi/storage/idb/IDBRequest.zig
@@ -44,6 +44,9 @@ _proto: *EventTarget,
_op: Operation = .none,
_error: ?anyerror = null,
_txn: ?*IDBTransaction = null,
+// Same request can show up multiple times in txn._requests, but it should only
+// be executed/fired in its last append (to preserve ordering).
+_txn_index: usize = 0,
_cursor: ?*IDBCursor = null,
_ready_state: ReadyState = .pending,
_result: Result = .{ .none = js.Undefined{} },
diff --git a/src/browser/webapi/storage/idb/IDBTransaction.zig b/src/browser/webapi/storage/idb/IDBTransaction.zig
index 64727b21f..fbc3259ad 100644
--- a/src/browser/webapi/storage/idb/IDBTransaction.zig
+++ b/src/browser/webapi/storage/idb/IDBTransaction.zig
@@ -145,11 +145,12 @@ pub fn abort(self: *IDBTransaction, exec: *Execution) !void {
self._engine.rollback();
}
- for (self._requests.items) |request| {
- request._op = .none;
- if (request._ready_state == .done) {
+ // request whose op already ran (op == .none) was delivered and is skipped.
+ for (self._requests.items, 0..) |request, i| {
+ if (i != request._txn_index or request._op == .none) {
continue;
}
+ request._op = .none;
request.setError(error.AbortError);
request.deliver(exec) catch |err| {
log.warn(.storage, "idb abort deliver", .{ .err = err });
@@ -162,7 +163,14 @@ pub fn abort(self: *IDBTransaction, exec: *Execution) !void {
// commit fails). Drives a transaction to a successful close — shared by the
// drain task and the open path's synchronous versionchange transaction.
pub fn settle(self: *IDBTransaction, exec: *Execution) void {
+ if (self._settled) {
+ return;
+ }
self.deliverPending(exec);
+ if (self._settled) {
+ // a request handler might have settled this (e.g. called abort)
+ return;
+ }
if (self._begun) {
self._engine.commit() catch |err| {
log.warn(.storage, "idb commit", .{ .err = err, .sqlite = self._engine.conn.lastError() });
@@ -201,6 +209,7 @@ pub fn newRequest(self: *IDBTransaction) !*IDBRequest {
}
pub fn enqueue(self: *IDBTransaction, request: *IDBRequest) !void {
+ request._txn_index = self._requests.items.len;
try self._requests.append(self._exec.arena, request);
}
@@ -318,6 +327,11 @@ fn deliverPending(self: *IDBTransaction, exec: *Execution) void {
var i: usize = 0;
while (i < self._requests.items.len) : (i += 1) {
+ // A handler may have aborted the transaction mid-delivery; abort() already
+ // delivered AbortError to the remaining requests, so stop here.
+ if (self._settled) {
+ return;
+ }
const request = self._requests.items[i];
request.execute(exec) catch |err| {
log.warn(.storage, "idb request execute", .{ .err = err });