Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

fix(workers): do not leak workers after closure (#41406)

Dmitry Gozmanfca6a5d12081
diff --git a/packages/playwright-core/src/server/chromium/crNetworkManager.ts b/packages/playwright-core/src/server/chromium/crNetworkManager.ts
index 9620171f92..e353798b03 100644
--- a/packages/playwright-core/src/server/chromium/crNetworkManager.ts
+++ b/packages/playwright-core/src/server/chromium/crNetworkManager.ts
@@ -99,6 +99,8 @@ export class CRNetworkManager {
if (info)
eventsHelper.removeEventListeners(info.eventListeners);
this._sessions.delete(session);
+ for (const request of this._page?.networkRequests() ?? [])
+ InterceptableRequest.detachIfNeeded(request, session);
}
private async _forEachSession(cb: (sessionInfo: SessionInfo) => Promise<any>) {
@@ -377,32 +379,7 @@ export class CRNetworkManager {
}
_createResponse(request: InterceptableRequest, responsePayload: Protocol.Network.Response, hasExtraInfo: boolean): network.Response {
- const getResponseBody = async () => {
- const contentLengthHeader = Object.entries(responsePayload.headers).find(header => header[0].toLowerCase() === 'content-length');
- const expectedLength = contentLengthHeader ? +contentLengthHeader[1] : undefined;
-
- const session = request.session;
- const response = await session.send('Network.getResponseBody', { requestId: request._requestId });
- if (response.body || !expectedLength)
- return Buffer.from(response.body, response.base64Encoded ? 'base64' : 'utf8');
-
- // Make sure no network requests sent while reading the body for fulfilled requests.
- if (request._originalRequestRoute?._fulfilled)
- return Buffer.from('');
-
- // For <link prefetch we are going to receive empty body with non-empty content-length expectation. Reach out for the actual content.
- const resource = await session.send('Network.loadNetworkResource', { url: request.request.url(), frameId: this._serviceWorker ? undefined : request.request.frame()!._id, options: { disableCache: false, includeCredentials: true } });
- const chunks: Buffer[] = [];
- while (resource.resource.stream) {
- const chunk = await session.send('IO.read', { handle: resource.resource.stream });
- chunks.push(Buffer.from(chunk.data, chunk.base64Encoded ? 'base64' : 'utf-8'));
- if (chunk.eof) {
- await session.send('IO.close', { handle: resource.resource.stream });
- break;
- }
- }
- return Buffer.concat(chunks);
- };
+ const getResponseBody = InterceptableRequest.createResponseBodyCallback(request.request);
const timingPayload = responsePayload.timing!;
let timing: network.ResourceTiming;
if (timingPayload && !this._responseExtraInfoTracker.servedFromCache(request._requestId)) {
@@ -577,6 +554,8 @@ export class CRNetworkManager {
}
}
+const kInterceptableRequest = Symbol('InterceptableRequest');
+
class InterceptableRequest {
readonly request: network.Request;
readonly _requestId: string;
@@ -589,6 +568,49 @@ class InterceptableRequest {
readonly _originalRequestRoute: RouteImpl | undefined;
session: CRSession;
+ private static from(request: network.Request): InterceptableRequest | undefined {
+ return (request as any)[kInterceptableRequest];
+ }
+
+ static detachIfNeeded(request: network.Request, session: CRSession) {
+ if (InterceptableRequest.from(request)?.session === session)
+ (request as any)[kInterceptableRequest] = undefined;
+ }
+
+ static createResponseBodyCallback(request: network.Request): () => Promise<Buffer> {
+ return async () => {
+ // Lookup the request lazily, so that the response does not retain the
+ // InterceptableRequest and its session after detachIfNeeded().
+ const interceptable = InterceptableRequest.from(request);
+ if (!interceptable)
+ throw new Error('Response body is unavailable');
+ const contentLength = request._existingResponse()?.headerValue('content-length');
+ const expectedLength = contentLength ? +contentLength : undefined;
+
+ const session = interceptable.session;
+ const response = await session.send('Network.getResponseBody', { requestId: interceptable._requestId });
+ if (response.body || !expectedLength)
+ return Buffer.from(response.body, response.base64Encoded ? 'base64' : 'utf8');
+
+ // Make sure no network requests sent while reading the body for fulfilled requests.
+ if (interceptable._originalRequestRoute?._fulfilled)
+ return Buffer.from('');
+
+ // For <link prefetch we are going to receive empty body with non-empty content-length expectation. Reach out for the actual content.
+ const resource = await session.send('Network.loadNetworkResource', { url: request.url(), frameId: request.serviceWorker() ? undefined : request.frame()!._id, options: { disableCache: false, includeCredentials: true } });
+ const chunks: Buffer[] = [];
+ while (resource.resource.stream) {
+ const chunk = await session.send('IO.read', { handle: resource.resource.stream });
+ chunks.push(Buffer.from(chunk.data, chunk.base64Encoded ? 'base64' : 'utf-8'));
+ if (chunk.eof) {
+ await session.send('IO.close', { handle: resource.resource.stream });
+ break;
+ }
+ }
+ return Buffer.concat(chunks);
+ };
+ }
+
constructor(options: {
session: CRSession,
context: contexts.BrowserContext;
@@ -622,6 +644,7 @@ class InterceptableRequest {
postDataBuffer = Buffer.concat(entries.map(entry => Buffer.from(entry.bytes!, 'base64')));
this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, toResourceType(requestWillBeSentEvent.type || 'Other'), method, postDataBuffer, headersOverride || headersObjectToArray(headers), requestWillBeSentEvent.wallTime * 1000);
+ (this.request as any)[kInterceptableRequest] = this;
}
}
diff --git a/packages/playwright-core/src/server/chromium/crPage.ts b/packages/playwright-core/src/server/chromium/crPage.ts
index 82139d2fac..40e6f98171 100644
--- a/packages/playwright-core/src/server/chromium/crPage.ts
+++ b/packages/playwright-core/src/server/chromium/crPage.ts
@@ -757,6 +757,8 @@ class FrameSession {
// This might be a worker...
const workerSession = this._workerSessions.get(event.sessionId);
if (workerSession) {
+ this._workerSessions.delete(event.sessionId);
+ this._crPage._networkManager.removeSession(workerSession);
workerSession.dispose();
this._page.removeWorker(event.sessionId);
return;
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index 531e168971..55f51723d2 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -537,7 +537,10 @@ export class WorkerDispatcher extends Dispatcher<Worker, channels.WorkerChannel,
timestamp: message.timestamp(),
});
});
- this.addObjectListener(Worker.Events.Close, () => this._dispatchEvent('close'));
+ this.addObjectListener(Worker.Events.Close, () => {
+ this._dispatchEvent('close');
+ this._dispose();
+ });
}
async disconnect(params: channels.WorkerDisconnectParams, progress: Progress): Promise<void> {
diff --git a/packages/playwright-core/src/server/index.ts b/packages/playwright-core/src/server/index.ts
index 194e618173..0dad0c0e6f 100644
--- a/packages/playwright-core/src/server/index.ts
+++ b/packages/playwright-core/src/server/index.ts
@@ -21,8 +21,9 @@ export { deviceDescriptors } from './deviceDescriptors';
export { DispatcherConnection, RootDispatcher, setMaxDispatchersForTest } from './dispatchers/dispatcher';
export { RequestDispatcher, ResponseDispatcher } from './dispatchers/networkDispatchers';
export { PlaywrightDispatcher } from './dispatchers/playwrightDispatcher';
+export { PageDispatcher, WorkerDispatcher } from './dispatchers/pageDispatcher';
export { Request, Response } from './network';
-export { Page } from './page';
+export { Page, Worker } from './page';
export { createPlaywright } from './playwright';
export { nullProgress } from './progress';
export { WebSocketTransport } from './transport';
diff --git a/tests/library/heap.spec.ts b/tests/library/heap.spec.ts
index 4c5a5e9a2d..15978d9dcc 100644
--- a/tests/library/heap.spec.ts
+++ b/tests/library/heap.spec.ts
@@ -50,6 +50,91 @@ async function queryObjectCount(type: Function): Promise<number> {
}
}
+// Debug helper that shows what exactly is retaining a given object type.
+// To get the constructorName, run "console.log(object.constructor.name)" in the test.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function findRetainerPaths(constructorName: string, maxPaths = 10): Promise<void> {
+ const session: import('inspector').Session = new (require('node:inspector').Session)();
+ session.connect();
+ const chunks: string[] = [];
+ session.on('HeapProfiler.addHeapSnapshotChunk', (m: any) => chunks.push(m.params.chunk));
+ try {
+ await new Promise<void>(f => session.post('HeapProfiler.takeHeapSnapshot', { reportProgress: false }, () => f()));
+ } finally {
+ session.disconnect();
+ }
+ const snapshot = JSON.parse(chunks.join(''));
+ const { nodes, edges, strings, snapshot: meta } = snapshot;
+ const nodeFields: string[] = meta.meta.node_fields;
+ const edgeFields: string[] = meta.meta.edge_fields;
+ const edgeTypes: string[] = meta.meta.edge_types[0];
+ const nf = nodeFields.length;
+ const ef = edgeFields.length;
+ const nodeTypeOff = nodeFields.indexOf('type');
+ const nodeNameOff = nodeFields.indexOf('name');
+ const nodeIdOff = nodeFields.indexOf('id');
+ const nodeEdgeCountOff = nodeFields.indexOf('edge_count');
+ const edgeTypeOff = edgeFields.indexOf('type');
+ const edgeNameOff = edgeFields.indexOf('name_or_index');
+ const edgeToOff = edgeFields.indexOf('to_node');
+ const nodeCount = nodes.length / nf;
+
+ // Compute the first-edge index for every node (edges are laid out in node order).
+ const firstEdge = new Uint32Array(nodeCount);
+ let edgeCursor = 0;
+ for (let i = 0; i < nodeCount; ++i) {
+ firstEdge[i] = edgeCursor;
+ edgeCursor += nodes[i * nf + nodeEdgeCountOff];
+ }
+
+ const nodeName = (i: number) => strings[nodes[i * nf + nodeNameOff]];
+ const nodeTypeName = (i: number) => meta.meta.node_types[0][nodes[i * nf + nodeTypeOff]];
+
+ // BFS from the synthetic root (node 0), recording how we reached each node.
+ const parent = new Int32Array(nodeCount).fill(-1);
+ const parentEdgeName = new Array<string>(nodeCount);
+ const visited = new Uint8Array(nodeCount);
+ visited[0] = 1;
+ const queue = [0];
+ for (let q = 0; q < queue.length; ++q) {
+ const from = queue[q];
+ const edgeStart = firstEdge[from];
+ const count = nodes[from * nf + nodeEdgeCountOff];
+ for (let e = 0; e < count; ++e) {
+ const base = (edgeStart + e) * ef;
+ const type = edgeTypes[edges[base + edgeTypeOff]];
+ if (type === 'weak')
+ continue; // Weak references do not retain.
+ const to = edges[base + edgeToOff] / nf;
+ if (visited[to])
+ continue;
+ visited[to] = 1;
+ parent[to] = from;
+ const rawName = edges[base + edgeNameOff];
+ parentEdgeName[to] = (type === 'element' || type === 'hidden') ? `[${rawName}]` : strings[rawName];
+ queue.push(to);
+ }
+ }
+
+ const targets: number[] = [];
+ for (let i = 0; i < nodeCount && targets.length < maxPaths; ++i) {
+ if (nodeTypeName(i) === 'object' && nodeName(i) === constructorName)
+ targets.push(i);
+ }
+ console.log(`\n===== retainer paths for ${constructorName} (showing ${targets.length}) =====`);
+ for (const target of targets) {
+ const path: string[] = [];
+ let cur = target;
+ while (cur !== -1) {
+ const label = `${nodeName(cur)} (${nodeTypeName(cur)} @${nodes[cur * nf + nodeIdOff]})`;
+ path.push(parent[cur] === -1 ? label : `${label} <--[${parentEdgeName[cur]}]--`);
+ cur = parent[cur];
+ }
+ console.log(' ' + path.join('\n '));
+ console.log(' ----');
+ }
+}
+
const clientClass = {
Page: null as Function,
BrowserContext: null as Function,
@@ -135,6 +220,22 @@ test('should not leak dispatchers after closing page', async ({ context, server
expect(await queryObjectCount(clientClass.Response)).toBe(0);
});
+test('should not leak workers', async ({ page }) => {
+ const before = await queryObjectCount(coreServer.Worker);
+ for (let i = 0; i < 5; ++i) {
+ const [workerHandle, workerObj] = await Promise.all([
+ page.evaluateHandle(index => new Worker(URL.createObjectURL(new Blob([String(index)], { type: 'application/javascript' }))), i),
+ page.waitForEvent('worker'),
+ ]);
+ await Promise.all([
+ workerObj.waitForEvent('close'),
+ workerHandle.evaluate(workerObj => workerObj.terminate()),
+ ]);
+ }
+ expect.soft(await queryObjectCount(coreServer.Worker)).toBe(before);
+ expect.soft(await queryObjectCount(coreServer.WorkerDispatcher)).toBe(0);
+});
+
test.describe(() => {
test.beforeEach(() => {
coreServer.setMaxDispatchersForTest(100);