Skip to content

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

chore: replace some progress.cleanup calls with try/catch (#36769)

Dmitry Gozman63d898d6326f
diff --git a/packages/playwright-core/src/server/android/android.ts b/packages/playwright-core/src/server/android/android.ts
index 3f8785ae62..7b171fd25a 100644
--- a/packages/playwright-core/src/server/android/android.ts
+++ b/packages/playwright-core/src/server/android/android.ts
@@ -34,7 +34,7 @@ import { removeFolders } from '../utils/fileUtils';
import { helper } from '../helper';
import { SdkObject, serverSideCallMetadata } from '../instrumentation';
import { gracefullyCloseSet } from '../utils/processLauncher';
-import { isAbortError, Progress, ProgressController } from '../progress';
+import { isAbortError, Progress, ProgressController, raceUncancellableOperationWithCleanup } from '../progress';
import { registry } from '../registry';
import type { BrowserOptions, BrowserProcess } from '../browser';
@@ -79,8 +79,7 @@ export class Android extends SdkObject {
newSerials.add(d.serial);
if (this._devices.has(d.serial))
continue;
- const device = await progress.raceWithCleanup(AndroidDevice.create(this, d, options), device => device.close());
- this._devices.set(d.serial, device);
+ await progress.race(AndroidDevice.create(this, d, options).then(device => this._devices.set(d.serial, device)));
}
for (const d of this._devices.keys()) {
if (!newSerials.has(d))
@@ -152,7 +151,7 @@ export class AndroidDevice extends SdkObject {
}
async open(progress: Progress, command: string): Promise<SocketBackend> {
- return await progress.raceWithCleanup(this._backend.open(`${command}`), socket => socket.close());
+ return await this._open(progress, command);
}
async screenshot(): Promise<Buffer> {
@@ -216,7 +215,7 @@ export class AndroidDevice extends SdkObject {
debug('pw:android')(`Polling the socket localabstract:${socketName}`);
while (!socket) {
try {
- socket = await progress.raceWithCleanup(this._backend.open(`localabstract:${socketName}`), socket => socket.close());
+ socket = await this._open(progress, `localabstract:${socketName}`);
} catch (e) {
if (isAbortError(e))
throw e;
@@ -273,8 +272,13 @@ export class AndroidDevice extends SdkObject {
await progress.race(this._backend.runCommand(`shell:echo "${Buffer.from(commandLine).toString('base64')}" | base64 -d > /data/local/tmp/chrome-command-line`));
await progress.race(this._backend.runCommand(`shell:am start -a android.intent.action.VIEW -d about:blank ${pkg}`));
const browserContext = await this._connectToBrowser(progress, socketName, options);
- await progress.race(this._backend.runCommand(`shell:rm /data/local/tmp/chrome-command-line`));
- return browserContext;
+ try {
+ await progress.race(this._backend.runCommand(`shell:rm /data/local/tmp/chrome-command-line`));
+ return browserContext;
+ } catch (error) {
+ await browserContext.close({ reason: 'Failed to launch' }).catch(() => {});
+ throw error;
+ }
}
private _defaultArgs(options: channels.AndroidDeviceLaunchBrowserParams, socketName: string): string[] {
@@ -315,43 +319,50 @@ export class AndroidDevice extends SdkObject {
private async _connectToBrowser(progress: Progress, socketName: string, options: types.BrowserContextOptions = {}): Promise<BrowserContext> {
const socket = await this._waitForLocalAbstract(progress, socketName);
- const androidBrowser = new AndroidBrowser(this, socket);
- progress.cleanupWhenAborted(() => androidBrowser.close());
- await progress.race(androidBrowser._init());
- this._browserConnections.add(androidBrowser);
-
- const artifactsDir = await progress.race(fs.promises.mkdtemp(ARTIFACTS_FOLDER));
- const cleanupArtifactsDir = async () => {
- const errors = (await removeFolders([artifactsDir])).filter(Boolean);
- for (let i = 0; i < (errors || []).length; ++i)
- debug('pw:android')(`exception while removing ${artifactsDir}: ${errors[i]}`);
- };
- progress.cleanupWhenAborted(cleanupArtifactsDir);
- gracefullyCloseSet.add(cleanupArtifactsDir);
- socket.on('close', async () => {
- gracefullyCloseSet.delete(cleanupArtifactsDir);
- cleanupArtifactsDir().catch(e => debug('pw:android')(`could not cleanup artifacts dir: ${e}`));
- });
- const browserOptions: BrowserOptions = {
- name: 'clank',
- isChromium: true,
- slowMo: 0,
- persistent: { ...options, noDefaultViewport: true },
- artifactsDir,
- downloadsPath: artifactsDir,
- tracesDir: artifactsDir,
- browserProcess: new ClankBrowserProcess(androidBrowser),
- proxy: options.proxy,
- protocolLogger: helper.debugProtocolLogger(),
- browserLogsCollector: new RecentLogsCollector(),
- originalLaunchOptions: {},
- };
- validateBrowserContextOptions(options, browserOptions);
+ try {
+ const androidBrowser = new AndroidBrowser(this, socket);
+ await progress.race(androidBrowser._init());
+ this._browserConnections.add(androidBrowser);
+
+ const artifactsDir = await progress.race(fs.promises.mkdtemp(ARTIFACTS_FOLDER));
+ const cleanupArtifactsDir = async () => {
+ const errors = (await removeFolders([artifactsDir])).filter(Boolean);
+ for (let i = 0; i < (errors || []).length; ++i)
+ debug('pw:android')(`exception while removing ${artifactsDir}: ${errors[i]}`);
+ };
+ gracefullyCloseSet.add(cleanupArtifactsDir);
+ socket.on('close', async () => {
+ gracefullyCloseSet.delete(cleanupArtifactsDir);
+ cleanupArtifactsDir().catch(e => debug('pw:android')(`could not cleanup artifacts dir: ${e}`));
+ });
+ const browserOptions: BrowserOptions = {
+ name: 'clank',
+ isChromium: true,
+ slowMo: 0,
+ persistent: { ...options, noDefaultViewport: true },
+ artifactsDir,
+ downloadsPath: artifactsDir,
+ tracesDir: artifactsDir,
+ browserProcess: new ClankBrowserProcess(androidBrowser),
+ proxy: options.proxy,
+ protocolLogger: helper.debugProtocolLogger(),
+ browserLogsCollector: new RecentLogsCollector(),
+ originalLaunchOptions: {},
+ };
+ validateBrowserContextOptions(options, browserOptions);
+
+ const browser = await progress.race(CRBrowser.connect(this.attribution.playwright, androidBrowser, browserOptions));
+ const defaultContext = browser._defaultContext!;
+ await defaultContext._loadDefaultContextAsIs(progress);
+ return defaultContext;
+ } catch (error) {
+ socket.close();
+ throw error;
+ }
+ }
- const browser = await progress.race(CRBrowser.connect(this.attribution.playwright, androidBrowser, browserOptions));
- const defaultContext = browser._defaultContext!;
- await defaultContext._loadDefaultContextAsIs(progress);
- return defaultContext;
+ private _open(progress: Progress, command: string): Promise<SocketBackend> {
+ return raceUncancellableOperationWithCleanup(progress, () => this._backend.open(command), socket => socket.close());
}
webViews(): channels.AndroidWebView[] {
@@ -361,7 +372,7 @@ export class AndroidDevice extends SdkObject {
async installApk(progress: Progress, content: Buffer, options?: { args?: string[] }): Promise<void> {
const args = options && options.args ? options.args : ['-r', '-t', '-S'];
debug('pw:android')('Opening install socket');
- const installSocket = await progress.raceWithCleanup(this._backend.open(`shell:cmd package install ${args.join(' ')} ${content.length}`), socket => socket.close());
+ const installSocket = await this._open(progress, `shell:cmd package install ${args.join(' ')} ${content.length}`);
debug('pw:android')('Writing driver bytes: ' + content.length);
await progress.race(installSocket.write(content));
const success = await progress.race(new Promise(f => installSocket.on('data', f)));
@@ -370,7 +381,7 @@ export class AndroidDevice extends SdkObject {
}
async push(progress: Progress, content: Buffer, path: string, mode = 0o644): Promise<void> {
- const socket = await progress.raceWithCleanup(this._backend.open(`sync:`), socket => socket.close());
+ const socket = await this._open(progress, `sync:`);
const sendHeader = async (command: string, length: number) => {
const buffer = Buffer.alloc(command.length + 4);
buffer.write(command, 0);
diff --git a/packages/playwright-core/src/server/bidi/bidiChromium.ts b/packages/playwright-core/src/server/bidi/bidiChromium.ts
index b3bfe54d5f..ac8639a1fc 100644
--- a/packages/playwright-core/src/server/bidi/bidiChromium.ts
+++ b/packages/playwright-core/src/server/bidi/bidiChromium.ts
@@ -82,6 +82,7 @@ export class BidiChromium extends BrowserType {
}
override attemptToGracefullyCloseBrowser(transport: ConnectionTransport): void {
+ // Note that it's fine to reuse the transport, since our connection ignores kBrowserCloseMessageId.
const bidiTransport = (transport as any)[kBidiOverCdpWrapper];
if (bidiTransport)
transport = bidiTransport;
diff --git a/packages/playwright-core/src/server/bidi/bidiFirefox.ts b/packages/playwright-core/src/server/bidi/bidiFirefox.ts
index 74530ee55a..7c96383fe1 100644
--- a/packages/playwright-core/src/server/bidi/bidiFirefox.ts
+++ b/packages/playwright-core/src/server/bidi/bidiFirefox.ts
@@ -78,6 +78,7 @@ export class BidiFirefox extends BrowserType {
}
override attemptToGracefullyCloseBrowser(transport: ConnectionTransport): void {
+ // Note that it's fine to reuse the transport, since our connection ignores kBrowserCloseMessageId.
transport.send({ method: 'browser.close', params: {}, id: kBrowserCloseMessageId });
}
diff --git a/packages/playwright-core/src/server/browser.ts b/packages/playwright-core/src/server/browser.ts
index 073731ba8e..6f9894eac4 100644
--- a/packages/playwright-core/src/server/browser.ts
+++ b/packages/playwright-core/src/server/browser.ts
@@ -20,9 +20,7 @@ import { Download } from './download';
import { SdkObject } from './instrumentation';
import { Page } from './page';
import { ClientCertificatesProxy } from './socksClientCertificatesInterceptor';
-import { ProgressController } from './progress';
-import type { CallMetadata } from './instrumentation';
import type * as types from './types';
import type { ProxySettings } from './types';
import type { RecentLogsCollector } from './utils/debugLogger';
@@ -92,28 +90,30 @@ export abstract class Browser extends SdkObject {
return this.options.sdkLanguage || this.attribution.playwright.options.sdkLanguage;
}
- newContextFromMetadata(metadata: CallMetadata, options: types.BrowserContextOptions): Promise<BrowserContext> {
- const controller = new ProgressController(metadata, this);
- return controller.run(progress => this.newContext(progress, options));
- }
-
async newContext(progress: Progress, options: types.BrowserContextOptions): Promise<BrowserContext> {
validateBrowserContextOptions(options, this.options);
let clientCertificatesProxy: ClientCertificatesProxy | undefined;
- if (options.clientCertificates?.length) {
- clientCertificatesProxy = await progress.raceWithCleanup(ClientCertificatesProxy.create(options), proxy => proxy.close());
- options = { ...options };
- options.proxyOverride = clientCertificatesProxy.proxySettings();
- options.internalIgnoreHTTPSErrors = true;
+ let context: BrowserContext | undefined;
+ try {
+ if (options.clientCertificates?.length) {
+ clientCertificatesProxy = await ClientCertificatesProxy.create(progress, options);
+ options = { ...options };
+ options.proxyOverride = clientCertificatesProxy.proxySettings();
+ options.internalIgnoreHTTPSErrors = true;
+ }
+ context = await progress.race(this.doCreateNewContext(options));
+ context._clientCertificatesProxy = clientCertificatesProxy;
+ if ((options as any).__testHookBeforeSetStorageState)
+ await progress.race((options as any).__testHookBeforeSetStorageState());
+ if (options.storageState)
+ await context.setStorageState(progress, options.storageState);
+ this.emit(Browser.Events.Context, context);
+ return context;
+ } catch (error) {
+ await context?.close({ reason: 'Failed to create context' }).catch(() => {});
+ await clientCertificatesProxy?.close().catch(() => {});
+ throw error;
}
- const context = await progress.raceWithCleanup(this.doCreateNewContext(options), context => context.close({ reason: 'Failed to create context' }));
- context._clientCertificatesProxy = clientCertificatesProxy;
- if ((options as any).__testHookBeforeSetStorageState)
- await progress.race((options as any).__testHookBeforeSetStorageState());
- if (options.storageState)
- await context.setStorageState(progress, options.storageState);
- this.emit(Browser.Events.Context, context);
- return context;
}
async newContextForReuse(progress: Progress, params: channels.BrowserNewContextForReuseParams): Promise<BrowserContext> {
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index 48668e6314..839554fdc8 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -334,10 +334,14 @@ export abstract class BrowserContext extends SdkObject {
const binding = new PageBinding(name, playwrightBinding, needsHandle);
binding.forClient = forClient;
this._pageBindings.set(name, binding);
- progress.cleanupWhenAborted(() => this._pageBindings.delete(name));
- await progress.race(this.doAddInitScript(binding.initScript));
- await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
- return binding;
+ try {
+ await progress.race(this.doAddInitScript(binding.initScript));
+ await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, 'main'));
+ return binding;
+ } catch (error) {
+ this._pageBindings.delete(name);
+ throw error;
+ }
}
async removeExposedBindings(bindings: PageBinding[]) {
@@ -370,21 +374,27 @@ export abstract class BrowserContext extends SdkObject {
async setExtraHTTPHeaders(progress: Progress, headers: types.HeadersArray) {
const oldHeaders = this._options.extraHTTPHeaders;
this._options.extraHTTPHeaders = headers;
- progress.cleanupWhenAborted(async () => {
+ try {
+ await progress.race(this.doUpdateExtraHTTPHeaders());
+ } catch (error) {
this._options.extraHTTPHeaders = oldHeaders;
- await this.doUpdateExtraHTTPHeaders();
- });
- await progress.race(this.doUpdateExtraHTTPHeaders());
+ // Note: no await, headers will be reset in the background as soon as possible.
+ this.doUpdateExtraHTTPHeaders().catch(() => {});
+ throw error;
+ }
}
async setOffline(progress: Progress, offline: boolean) {
const oldOffline = this._options.offline;
this._options.offline = offline;
- progress.cleanupWhenAborted(async () => {
+ try {
+ await progress.race(this.doUpdateOffline());
+ } catch (error) {
this._options.offline = oldOffline;
- await this.doUpdateOffline();
- });
- await progress.race(this.doUpdateOffline());
+ // Note: no await, offline will be reset in the background as soon as possible.
+ this.doUpdateOffline().catch(() => {});
+ throw error;
+ }
}
async _loadDefaultContextAsIs(progress: Progress): Promise<Page | undefined> {
@@ -442,13 +452,18 @@ export abstract class BrowserContext extends SdkObject {
async addInitScript(progress: Progress | undefined, source: string) {
const initScript = new InitScript(source);
this.initScripts.push(initScript);
- progress?.cleanupWhenAborted(() => this.removeInitScripts([initScript]));
- const promise = this.doAddInitScript(initScript);
- if (progress)
- await progress.race(promise);
- else
- await promise;
- return initScript;
+ try {
+ const promise = this.doAddInitScript(initScript);
+ if (progress)
+ await progress.race(promise);
+ else
+ await promise;
+ return initScript;
+ } catch (error) {
+ // Note: no await, init script will be removed in the background as soon as possible.
+ this.removeInitScripts([initScript]).catch(() => {});
+ throw error;
+ }
}
async removeInitScripts(initScripts: InitScript[]) {
@@ -528,14 +543,19 @@ export abstract class BrowserContext extends SdkObject {
}
async newPage(progress: Progress, isServerSide: boolean): Promise<Page> {
- const page = await progress.raceWithCleanup(this.doCreateNewPage(isServerSide), page => page.close());
- const pageOrError = await progress.race(page.waitForInitializedOrError());
- if (pageOrError instanceof Page) {
- if (pageOrError.isClosed())
- throw new Error('Page has been closed.');
- return pageOrError;
+ const page = await progress.race(this.doCreateNewPage(isServerSide));
+ try {
+ const pageOrError = await progress.race(page.waitForInitializedOrError());
+ if (pageOrError instanceof Page) {
+ if (pageOrError.isClosed())
+ throw new Error('Page has been closed.');
+ return pageOrError;
+ }
+ throw pageOrError;
+ } catch (error) {
+ await page.close({ reason: 'Failed to create page' }).catch(() => {});
+ throw error;
}
- throw pageOrError;
}
addVisitedOrigin(origin: string) {
@@ -574,17 +594,20 @@ export abstract class BrowserContext extends SdkObject {
// If there are still origins to save, create a blank page to iterate over origins.
if (originsToSave.size) {
const page = await this.newPage(progress, true);
- await page.addRequestInterceptor(progress, route => {
- route.fulfill({ body: '<html></html>' }).catch(() => {});
- }, 'prepend');
- for (const origin of originsToSave) {
- const frame = page.mainFrame();
- await frame.gotoImpl(progress, origin, {});
- const storage: SerializedStorage = await progress.race(frame.evaluateExpression(collectScript, { world: 'utility' }));
- if (storage.localStorage.length || storage.indexedDB?.length)
- result.origins.push({ origin, localStorage: storage.localStorage, indexedDB: storage.indexedDB });
+ try {
+ await page.addRequestInterceptor(progress, route => {
+ route.fulfill({ body: '<html></html>' }).catch(() => {});
+ }, 'prepend');
+ for (const origin of originsToSave) {
+ const frame = page.mainFrame();
+ await frame.gotoImpl(progress, origin, {});
+ const storage: SerializedStorage = await progress.race(frame.evaluateExpression(collectScript, { world: 'utility' }));
+ if (storage.localStorage.length || storage.indexedDB?.length)
+ result.origins.push({ origin, localStorage: storage.localStorage, indexedDB: storage.indexedDB });
+ }
+ } finally {
+ await page.close();
}
- await page.close();
}
return result;
}
@@ -602,20 +625,20 @@ export abstract class BrowserContext extends SdkObject {
const interceptor = (route: network.Route) => {
route.fulfill({ body: '<html></html>' }).catch(() => {});
};
-
- progress.cleanupWhenAborted(() => page.removeRequestInterceptor(interceptor));
await page.addRequestInterceptor(progress, interceptor, 'prepend');
- for (const origin of new Set([...oldOrigins, ...newOrigins.keys()])) {
- const frame = page.mainFrame();
- await frame.gotoImpl(progress, origin, {});
- await progress.race(frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin)));
- }
-
- await page.removeRequestInterceptor(interceptor);
+ try {
+ for (const origin of new Set([...oldOrigins, ...newOrigins.keys()])) {
+ const frame = page.mainFrame();
+ await frame.gotoImpl(progress, origin, {});
+ await progress.race(frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin)));
+ }
- this._origins = new Set([...newOrigins.keys()]);
- // It is safe to not restore the URL to about:blank since we are doing it in Page::resetForReuse.
+ this._origins = new Set([...newOrigins.keys()]);
+ // It is safe to not restore the URL to about:blank since we are doing it in Page::resetForReuse.
+ } finally {
+ await page.removeRequestInterceptor(interceptor);
+ }
}
isSettingStorageState(): boolean {
@@ -623,12 +646,13 @@ export abstract class BrowserContext extends SdkObject {
}
async setStorageState(progress: Progress, state: NonNullable<channels.BrowserNewContextParams['storageState']>) {
+ let page: Page | undefined;
this._settingStorageState = true;
try {
if (state.cookies)
await progress.race(this.addCookies(state.cookies));
if (state.origins && state.origins.length) {
- const page = await this.newPage(progress, true);
+ page = await this.newPage(progress, true);
await page.addRequestInterceptor(progress, route => {
route.fulfill({ body: '<html></html>' }).catch(() => {});
}, 'prepend');
@@ -643,12 +667,12 @@ export abstract class BrowserContext extends SdkObject {
})()`;
await progress.race(frame.evaluateExpression(restoreScript, { world: 'utility' }));
}
- await page.close();
}
} catch (error) {
rewriteErrorMessage(error, `Error setting storage state:\n` + error.message);
throw error;
} finally {
+ await page?.close();
this._settingStorageState = false;
}
}
diff --git a/packages/playwright-core/src/server/browserType.ts b/packages/playwright-core/src/server/browserType.ts
index 483c5b958e..4bf132fee5 100644
--- a/packages/playwright-core/src/server/browserType.ts
+++ b/packages/playwright-core/src/server/browserType.ts
@@ -23,7 +23,7 @@ import { debugMode } from './utils/debug';
import { assert } from '../utils/isomorphic/assert';
import { ManualPromise } from '../utils/isomorphic/manualPromise';
import { DEFAULT_PLAYWRIGHT_TIMEOUT } from '../utils/isomorphic/time';
-import { existsAsync, removeFolders } from './utils/fileUtils';
+import { existsAsync } from './utils/fileUtils';
import { helper } from './helper';
import { SdkObject } from './instrumentation';
import { PipeTransport } from './pipeTransport';
@@ -78,14 +78,19 @@ export abstract class BrowserType extends SdkObject {
// Note: Any initial TLS requests will fail since we rely on the Page/Frames initialize which sets ignoreHTTPSErrors.
let clientCertificatesProxy: ClientCertificatesProxy | undefined;
if (options.clientCertificates?.length) {
- clientCertificatesProxy = await progress.raceWithCleanup(ClientCertificatesProxy.create(options), proxy => proxy.close());
+ clientCertificatesProxy = await ClientCertificatesProxy.create(progress, options);
launchOptions.proxyOverride = clientCertificatesProxy.proxySettings();
options = { ...options };
options.internalIgnoreHTTPSErrors = true;
}
- const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, helper.debugProtocolLogger(), userDataDir).catch(e => { throw this._rewriteStartupLog(e); });
- browser._defaultContext!._clientCertificatesProxy = clientCertificatesProxy;
- return browser._defaultContext!;
+ try {
+ const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, helper.debugProtocolLogger(), userDataDir).catch(e => { throw this._rewriteStartupLog(e); });
+ browser._defaultContext!._clientCertificatesProxy = clientCertificatesProxy;
+ return browser._defaultContext!;
+ } catch (error) {
+ await clientCertificatesProxy?.close().catch(() => {});
+ throw error;
+ }
}
async _innerLaunchWithRetries(progress: Progress, options: types.LaunchOptions, persistent: types.BrowserContextOptions | undefined, protocolLogger: types.ProtocolLogger, userDataDir?: string): Promise<Browser> {
@@ -106,35 +111,40 @@ export abstract class BrowserType extends SdkObject {
options.proxy = options.proxy ? normalizeProxySettings(options.proxy) : undefined;
const browserLogsCollector = new RecentLogsCollector();
const { browserProcess, userDataDir, artifactsDir, transport } = await this._launchProcess(progress, options, !!persistent, browserLogsCollector, maybeUserDataDir);
- if ((options as any).__testHookBeforeCreateBrowser)
- await progress.race((options as any).__testHookBeforeCreateBrowser());
- const browserOptions: BrowserOptions = {
- name: this._name,
- isChromium: this._name === 'chromium',
- channel: options.channel,
- slowMo: options.slowMo,
- persistent,
- headful: !options.headless,
- artifactsDir,
- downloadsPath: (options.downloadsPath || artifactsDir)!,
- tracesDir: (options.tracesDir || artifactsDir)!,
- browserProcess,
- customExecutablePath: options.executablePath,
- proxy: options.proxy,
- protocolLogger,
- browserLogsCollector,
- wsEndpoint: transport instanceof WebSocketTransport ? transport.wsEndpoint : undefined,
- originalLaunchOptions: options,
- };
- if (persistent)
- validateBrowserContextOptions(persistent, browserOptions);
- copyTestHooks(options, browserOptions);
- const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
- (browser as any)._userDataDirForTest = userDataDir;
- // We assume no control when using custom arguments, and do not prepare the default context in that case.
- if (persistent && !options.ignoreAllDefaultArgs)
- await browser._defaultContext!._loadDefaultContext(progress);
- return browser;
+ try {
+ if ((options as any).__testHookBeforeCreateBrowser)
+ await progress.race((options as any).__testHookBeforeCreateBrowser());
+ const browserOptions: BrowserOptions = {
+ name: this._name,
+ isChromium: this._name === 'chromium',
+ channel: options.channel,
+ slowMo: options.slowMo,
+ persistent,
+ headful: !options.headless,
+ artifactsDir,
+ downloadsPath: (options.downloadsPath || artifactsDir)!,
+ tracesDir: (options.tracesDir || artifactsDir)!,
+ browserProcess,
+ customExecutablePath: options.executablePath,
+ proxy: options.proxy,
+ protocolLogger,
+ browserLogsCollector,
+ wsEndpoint: transport instanceof WebSocketTransport ? transport.wsEndpoint : undefined,
+ originalLaunchOptions: options,
+ };
+ if (persistent)
+ validateBrowserContextOptions(persistent, browserOptions);
+ copyTestHooks(options, browserOptions);
+ const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
+ (browser as any)._userDataDirForTest = userDataDir;
+ // We assume no control when using custom arguments, and do not prepare the default context in that case.
+ if (persistent && !options.ignoreAllDefaultArgs)
+ await browser._defaultContext!._loadDefaultContext(progress);
+ return browser;
+ } catch (error) {
+ await browserProcess.close().catch(() => {});
+ throw error;
+ }
}
private async _prepareToLaunch(options: types.LaunchOptions, isPersistent: boolean, userDataDir: string | undefined) {
@@ -194,7 +204,6 @@ export abstract class BrowserType extends SdkObject {
const env = options.env ? envArrayToObject(options.env) : process.env;
const prepared = await progress.race(this._prepareToLaunch(options, isPersistent, userDataDir));
- progress.cleanupWhenAborted(() => removeFolders(prepared.tempDirectories));
// Note: it is important to define these variables before launchProcess, so that we don't get
// "Cannot access 'browserServer' before initialization" if something went wrong.
@@ -217,10 +226,12 @@ export abstract class BrowserType extends SdkObject {
attemptToGracefullyClose: async () => {
if ((options as any).__testHookGracefullyClose)
await (options as any).__testHookGracefullyClose();
- // We try to gracefully close to prevent crash reporting and core dumps.
- // Note that it's fine to reuse the pipe transport, since
- // our connection ignores kBrowserCloseMessageId.
- this.attemptToGracefullyCloseBrowser(transport!);
+ if (transport) {
+ // We try to gracefully close to prevent crash reporting and core dumps.
+ this.attemptToGracefullyCloseBrowser(transport);
+ } else {
+ throw new Error('Force-killing the browser because no transport is available to gracefully close it.');
+ }
},
onExit: (exitCode, signal) => {
// Unblock launch when browser prematurely exits.
@@ -249,19 +260,22 @@ export abstract class BrowserType extends SdkObject {
close: () => closeOrKill((options as any).__testHookBrowserCloseTimeout || DEFAULT_PLAYWRIGHT_TIMEOUT),
kill
};
- progress.cleanupWhenAborted(() => closeOrKill(DEFAULT_PLAYWRIGHT_TIMEOUT));
- const { wsEndpoint } = await progress.race([
- this.waitForReadyState(options, browserLogsCollector),
- exitPromise.then(() => ({ wsEndpoint: undefined })),
- ]);
- if (options.cdpPort !== undefined || !this.supportsPipeTransport()) {
- transport = await WebSocketTransport.connect(progress, wsEndpoint!);
- } else {
- const stdio = launchedProcess.stdio as unknown as [NodeJS.ReadableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.ReadableStream];
- transport = new PipeTransport(stdio[3], stdio[4]);
+ try {
+ const { wsEndpoint } = await progress.race([
+ this.waitForReadyState(options, browserLogsCollector),
+ exitPromise.then(() => ({ wsEndpoint: undefined })),
+ ]);
+ if (options.cdpPort !== undefined || !this.supportsPipeTransport()) {
+ transport = await WebSocketTransport.connect(progress, wsEndpoint!);
+ } else {
+ const stdio = launchedProcess.stdio as unknown as [NodeJS.ReadableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.WritableStream, NodeJS.ReadableStream];
+ transport = new PipeTransport(stdio[3], stdio[4]);
+ }
+ return { browserProcess, artifactsDir: prepared.artifactsDir, userDataDir: prepared.userDataDir, transport };
+ } catch (error) {
+ await closeOrKill(DEFAULT_PLAYWRIGHT_TIMEOUT).catch(() => {});
+ throw error;
}
- progress.cleanupWhenAborted(() => transport.close());
- return { browserProcess, artifactsDir: prepared.artifactsDir, userDataDir: prepared.userDataDir, transport };
}
async _createArtifactDirs(options: types.LaunchOptions): Promise<void> {
diff --git a/packages/playwright-core/src/server/chromium/chromium.ts b/packages/playwright-core/src/server/chromium/chromium.ts
index 18d3570375..b089cccc2d 100644
--- a/packages/playwright-core/src/server/chromium/chromium.ts
+++ b/packages/playwright-core/src/server/chromium/chromium.ts
@@ -76,40 +76,47 @@ export class Chromium extends BrowserType {
headersMap['User-Agent'] = getUserAgent();
const artifactsDir = await progress.race(fs.promises.mkdtemp(ARTIFACTS_FOLDER));
-
- const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
- const chromeTransport = await WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap });
- progress.cleanupWhenAborted(() => chromeTransport.close());
- const cleanedUp = new ManualPromise<void>();
const doCleanup = async () => {
await removeFolders([artifactsDir]);
- await onClose?.();
- cleanedUp.resolve();
+ const cb = onClose;
+ onClose = undefined; // Make sure to only call onClose once.
+ await cb?.();
};
+
+ let chromeTransport: WebSocketTransport | undefined;
const doClose = async () => {
- await chromeTransport.closeAndWait();
- await cleanedUp;
- };
- const browserProcess: BrowserProcess = { close: doClose, kill: doClose };
- const persistent: types.BrowserContextOptions = { noDefaultViewport: true };
- const browserOptions: BrowserOptions = {
- slowMo: options.slowMo,
- name: 'chromium',
- isChromium: true,
- persistent,
- browserProcess,
- protocolLogger: helper.debugProtocolLogger(),
- browserLogsCollector: new RecentLogsCollector(),
- artifactsDir,
- downloadsPath: options.downloadsPath || artifactsDir,
- tracesDir: options.tracesDir || artifactsDir,
- originalLaunchOptions: {},
+ await chromeTransport?.closeAndWait();
+ await doCleanup();
};
- validateBrowserContextOptions(persistent, browserOptions);
- const browser = await progress.race(CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
- browser._isCollocatedWithServer = false;
- browser.on(Browser.Events.Disconnected, doCleanup);
- return browser;
+
+ try {
+ const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
+ chromeTransport = await WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap });
+
+ const browserProcess: BrowserProcess = { close: doClose, kill: doClose };
+ const persistent: types.BrowserContextOptions = { noDefaultViewport: true };
+ const browserOptions: BrowserOptions = {
+ slowMo: options.slowMo,
+ name: 'chromium',
+ isChromium: true,
+ persistent,
+ browserProcess,
+ protocolLogger: helper.debugProtocolLogger(),
+ browserLogsCollector: new RecentLogsCollector(),
+ artifactsDir,
+ downloadsPath: options.downloadsPath || artifactsDir,
+ tracesDir: options.tracesDir || artifactsDir,
+ originalLaunchOptions: {},
+ };
+ validateBrowserContextOptions(persistent, browserOptions);
+ const browser = await progress.race(CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
+ browser._isCollocatedWithServer = false;
+ browser.on(Browser.Events.Disconnected, doCleanup);
+ return browser;
+ } catch (error) {
+ await doClose().catch(() => {});
+ throw error;
+ }
}
private _createDevTools() {
@@ -163,6 +170,7 @@ export class Chromium extends BrowserType {
}
override attemptToGracefullyCloseBrowser(transport: ConnectionTransport): void {
+ // Note that it's fine to reuse the transport, since our connection ignores kBrowserCloseMessageId.
const message: ProtocolRequest = { method: 'Browser.close', id: kBrowserCloseMessageId, params: {} };
transport.send(message);
}
diff --git a/packages/playwright-core/src/server/chromium/crCoverage.ts b/packages/playwright-core/src/server/chromium/crCoverage.ts
index 800f7c5094..cf68dd59f4 100644
--- a/packages/playwright-core/src/server/chromium/crCoverage.ts
+++ b/packages/playwright-core/src/server/chromium/crCoverage.ts
@@ -17,6 +17,7 @@
import { assert } from '../../utils';
import { eventsHelper } from '../utils/eventsHelper';
+import { raceUncancellableOperationWithCleanup } from '../progress';
import type { CRSession } from './crConnection';
import type { Protocol } from './protocol';
@@ -35,8 +36,7 @@ export class CRCoverage {
}
async startJSCoverage(progress: Progress, options: channels.PageStartJSCoverageParams) {
- progress.cleanupWhenAborted(() => this._jsCoverage.stop());
- await progress.race(this._jsCoverage.start(options));
+ await raceUncancellableOperationWithCleanup(progress, () => this._jsCoverage.start(options), () => this._jsCoverage.stop());
}
async stopJSCoverage(): Promise<channels.PageStopJSCoverageResult> {
@@ -44,8 +44,7 @@ export class CRCoverage {
}
async startCSSCoverage(progress: Progress, options: channels.PageStartCSSCoverageParams) {
- progress.cleanupWhenAborted(() => this._cssCoverage.stop());
- await progress.race(this._cssCoverage.start(options));
+ await raceUncancellableOperationWithCleanup(progress, () => this._cssCoverage.start(options), () => this._cssCoverage.stop());
}
async stopCSSCoverage(): Promise<channels.PageStopCSSCoverageResult> {
diff --git a/packages/playwright-core/src/server/firefox/firefox.ts b/packages/playwright-core/src/server/firefox/firefox.ts
index 56040fc152..79dca47465 100644
--- a/packages/playwright-core/src/server/firefox/firefox.ts
+++ b/packages/playwright-core/src/server/firefox/firefox.ts
@@ -65,6 +65,7 @@ export class Firefox extends BrowserType {
}
override attemptToGracefullyCloseBrowser(transport: ConnectionTransport): void {
+ // Note that it's fine to reuse the transport, since our connection ignores kBrowserCloseMessageId.
const message = { method: 'Browser.close', params: {}, id: kBrowserCloseMessageId };
transport.send(message);
}
diff --git a/packages/playwright-core/src/server/frames.ts b/packages/playwright-core/src/server/frames.ts
index e4fd5ab84e..04a469220a 100644
--- a/packages/playwright-core/src/server/frames.ts
+++ b/packages/playwright-core/src/server/frames.ts
@@ -761,7 +761,7 @@ export class Frame extends SdkObject {
return null;
return continuePolling;
}
- const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, root }) => {
+ const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, root }) => {
if (root && !root.isConnected)
throw injected.createStacklessError('Element is not attached to the DOM');
const elements = injected.querySelectorAll(info.parsed, root || document);
@@ -776,7 +776,7 @@ export class Frame extends SdkObject {
log = ` locator resolved to ${visible ? 'visible' : 'hidden'} ${injected.previewNode(element)}`;
}
return { log, element, visible, attached: !!element };
- }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }), handle => handle.dispose());
+ }, { info: resolved.info, root: resolved.frame === this ? scope : undefined }));
const { log, visible, attached } = await progress.race(result.evaluate(r => ({ log: r.log, visible: r.visible, attached: r.attached })));
if (log)
progress.log(log);
@@ -1085,7 +1085,7 @@ export class Frame extends SdkObject {
const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict }));
if (!resolved)
return continuePolling;
- const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, callId }) => {
+ const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, callId }) => {
const elements = injected.querySelectorAll(info.parsed, document);
if (callId)
injected.markTargetElements(new Set(elements), callId);
@@ -1099,7 +1099,7 @@ export class Frame extends SdkObject {
log = ` locator resolved to ${injected.previewNode(element)}`;
}
return { log, success: !!element, element };
- }, { info: resolved.info, callId: progress.metadata.id }), handle => handle.dispose());
+ }, { info: resolved.info, callId: progress.metadata.id }));
const { log, success } = await progress.race(result.evaluate(r => ({ log: r.log, success: r.success })));
if (log)
progress.log(log);
diff --git a/packages/playwright-core/src/server/localUtils.ts b/packages/playwright-core/src/server/localUtils.ts
index 2071260ceb..47c93362b6 100644
--- a/packages/playwright-core/src/server/localUtils.ts
+++ b/packages/playwright-core/src/server/localUtils.ts
@@ -141,13 +141,18 @@ export async function harOpen(progress: Progress, harBackends: Map<string, HarBa
let harBackend: HarBackend;
if (params.file.endsWith('.zip')) {
const zipFile = new ZipFile(params.file);
- const entryNames = await zipFile.entries();
- const harEntryName = entryNames.find(e => e.endsWith('.har'));
- if (!harEntryName)
- return { error: 'Specified archive does not have a .har file' };
- const har = await progress.raceWithCleanup(zipFile.read(harEntryName), () => zipFile.close());
- const harFile = JSON.parse(har.toString()) as har.HARFile;
- harBackend = new HarBackend(harFile, null, zipFile);
+ try {
+ const entryNames = await progress.race(zipFile.entries());
+ const harEntryName = entryNames.find(e => e.endsWith('.har'));
+ if (!harEntryName)
+ return { error: 'Specified archive does not have a .har file' };
+ const har = await progress.race(zipFile.read(harEntryName));
+ const harFile = JSON.parse(har.toString()) as har.HARFile;
+ harBackend = new HarBackend(harFile, null, zipFile);
+ } catch (error) {
+ zipFile.close();
+ throw error;
+ }
} else {
const harFile = JSON.parse(await progress.race(fs.promises.readFile(params.file, 'utf-8'))) as har.HARFile;
harBackend = new HarBackend(harFile, path.dirname(params.file), null);
diff --git a/packages/playwright-core/src/server/progress.ts b/packages/playwright-core/src/server/progress.ts
index dee57073c4..e299c38e17 100644
--- a/packages/playwright-core/src/server/progress.ts
+++ b/packages/playwright-core/src/server/progress.ts
@@ -78,15 +78,6 @@ export class ProgressController {
const promises = Array.isArray(promise) ? promise : [promise];
return Promise.race([...promises, this._forceAbortPromise]);
},
- raceWithCleanup: <T>(promise: Promise<T>, cleanup: (result: T) => any) => {
- return progress.race(promise.then(result => {
- if (this._state !== 'running')
- cleanup(result);
- else
- this._cleanups.push(() => cleanup(result));
- return result;
- }));
- },
wait: async (timeout: number) => {
let timer: NodeJS.Timeout;
const promise = new Promise<void>(f => timer = setTimeout(f, timeout));
@@ -133,3 +124,19 @@ const kAbortErrorSymbol = Symbol('kAbortError');
export function isAbortError(error: Error): boolean {
return !!(error as any)[kAbortErrorSymbol];
}
+
+// Use this method to race some external operation that you really want to undo
+// when it goes beyond the progress abort.
+export async function raceUncancellableOperationWithCleanup<T>(progress: Progress, run: () => Promise<T>, cleanup: (t: T) => void | Promise<unknown>): Promise<T> {
+ let aborted = false;
+ try {
+ return await progress.race(run().then(async t => {
+ if (aborted)
+ await cleanup(t);
+ return t;
+ }));
+ } catch (error) {
+ aborted = true;
+ throw error;
+ }
+}
diff --git a/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts b/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts
index e5dd51bfb0..d244445374 100644
--- a/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts
+++ b/packages/playwright-core/src/server/socksClientCertificatesInterceptor.ts
@@ -31,6 +31,7 @@ import { getProxyForUrl } from '../utilsBundle';
import type * as types from './types';
import type { SocksSocketClosedPayload, SocksSocketDataPayload, SocksSocketRequestedPayload } from './utils/socksProxy';
import type https from 'https';
+import type { Progress } from '@protocol/progress';
let dummyServerTlsOptions: tls.TlsOptions | undefined = undefined;
function loadDummyServerCertsIfNeeded() {
@@ -306,10 +307,15 @@ export class ClientCertificatesProxy {
}
}
- public static async create(contextOptions: Pick<types.BrowserContextOptions, 'clientCertificates' | 'ignoreHTTPSErrors' | 'proxy'>) {
+ public static async create(progress: Progress, contextOptions: Pick<types.BrowserContextOptions, 'clientCertificates' | 'ignoreHTTPSErrors' | 'proxy'>) {
const proxy = new ClientCertificatesProxy(contextOptions);
- await proxy._socksProxy.listen(0, '127.0.0.1');
- return proxy;
+ try {
+ await progress.race(proxy._socksProxy.listen(0, '127.0.0.1'));
+ return proxy;
+ } catch (error) {
+ await proxy.close();
+ throw error;
+ }
}
public proxySettings(): types.ProxySettings {
diff --git a/packages/playwright-core/src/server/utils/processLauncher.ts b/packages/playwright-core/src/server/utils/processLauncher.ts
index 2f204674ec..e027708c1b 100644
--- a/packages/playwright-core/src/server/utils/processLauncher.ts
+++ b/packages/playwright-core/src/server/utils/processLauncher.ts
@@ -164,7 +164,10 @@ export async function launchProcess(options: LaunchProcessOptions): Promise<Laun
spawnedProcess.once('error', error => {
failed(new Error('Failed to launch: ' + error));
});
- return failedPromise.then(e => Promise.reject(e));
+ return failedPromise.then(async error => {
+ await cleanup();
+ throw error;
+ });
}
options.log(`<launched> pid=${spawnedProcess.pid}`);
diff --git a/packages/playwright-core/src/server/webkit/webkit.ts b/packages/playwright-core/src/server/webkit/webkit.ts
index 9d147cc1f3..27ae2a7a05 100644
--- a/packages/playwright-core/src/server/webkit/webkit.ts
+++ b/packages/playwright-core/src/server/webkit/webkit.ts
@@ -54,6 +54,7 @@ export class WebKit extends BrowserType {
}
override attemptToGracefullyCloseBrowser(transport: ConnectionTransport): void {
+ // Note that it's fine to reuse the transport, since our connection ignores kBrowserCloseMessageId.
transport.send({ method: 'Playwright.close', params: {}, id: kBrowserCloseMessageId });
}
diff --git a/packages/protocol/src/progress.d.ts b/packages/protocol/src/progress.d.ts
index 55166c318d..6890b3a048 100644
--- a/packages/protocol/src/progress.d.ts
+++ b/packages/protocol/src/progress.d.ts
@@ -28,14 +28,13 @@ import type { CallMetadata } from './callMetadata';
// In this case, it is important that awaited method has no side effects, for example
// it is a read-only browser protocol call.
// - In rare cases, when the awaited method does not take a Progress argument,
-// but it does have side effects such as creating a page - a proper cleanup
+// but it does have side effects such as creating a page - a proper cleanup
// must be taken in case Progress is aborted before the awaited method finishes.
-// That's usually done by `progress.raceWithCleanup()` or `progress.cleanupWhenAborted()`.
+// That's usually done by `progress.cleanupWhenAborted()`.
export interface Progress {
log(message: string): void;
cleanupWhenAborted(cleanup: (error: Error | undefined) => any): void;
race<T>(promise: Promise<T> | Promise<T>[]): Promise<T>;
- raceWithCleanup<T>(promise: Promise<T>, cleanup: (result: T) => any): Promise<T>;
wait(timeout: number): Promise<void>;
metadata: CallMetadata;
}