Filip/playwright
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

chore: encapsulate more launching logic in BrowserType (#2339)

Browse source
This commit is contained in:
Dmitry Gozman 2020-05-22 16:06:00 -07:00 committed by GitHub
parent aac5bf24ec
commit 27d30fe162
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 87 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/server/browserServer.ts
View file

@ -17,13 +17,11 @@
import { ChildProcess } from 'child_process'; import { ChildProcess } from 'child_process';
import { EventEmitter } from 'events'; import { EventEmitter } from 'events';
import { helper } from '../helper'; import { helper } from '../helper';
import { RootLogger } from '../logger';
import { LaunchOptions, processBrowserArgOptions } from './browserType';
import { ConnectionTransport } from '../transport';
export class WebSocketWrapper { export class WebSocketWrapper {
readonly wsEndpoint: string; readonly wsEndpoint: string;
private _bindings: (Map<any, any> | Set<any>)[]; private _bindings: (Map<any, any> | Set<any>)[];
constructor(wsEndpoint: string, bindings: (Map<any, any>|Set<any>)[]) { constructor(wsEndpoint: string, bindings: (Map<any, any>|Set<any>)[]) {
this.wsEndpoint = wsEndpoint; this.wsEndpoint = wsEndpoint;
this._bindings = bindings; this._bindings = bindings;
@ -53,24 +51,12 @@ export class WebSocketWrapper {
export class BrowserServer extends EventEmitter { export class BrowserServer extends EventEmitter {
private _process: ChildProcess; private _process: ChildProcess;
private _gracefullyClose: (() => Promise<void>); private _gracefullyClose: (() => Promise<void>);
private _webSocketWrapper: WebSocketWrapper | null = null; _webSocketWrapper: WebSocketWrapper | null = null;
readonly _launchOptions: LaunchOptions;
readonly _logger: RootLogger;
readonly _downloadsPath: string | undefined;
readonly _transport: ConnectionTransport;
readonly _headful: boolean;
constructor(options: LaunchOptions, process: ChildProcess, gracefullyClose: () => Promise<void>, transport: ConnectionTransport, downloadsPath: string | undefined, webSocketWrapper: WebSocketWrapper | null) { constructor(process: ChildProcess, gracefullyClose: () => Promise<void>) {
super(); super();
this._launchOptions = options;
this._headful = !processBrowserArgOptions(options).headless;
this._logger = new RootLogger(options.logger);
this._process = process; this._process = process;
this._gracefullyClose = gracefullyClose; this._gracefullyClose = gracefullyClose;
this._transport = transport;
this._downloadsPath = downloadsPath;
this._webSocketWrapper = webSocketWrapper;
} }
process(): ChildProcess { process(): ChildProcess {

104
src/server/browserType.ts
View file

@ -59,7 +59,6 @@ type ConnectOptions = {
logger?: Logger, logger?: Logger,
timeout?: number, timeout?: number,
}; };
export type LaunchType = 'local' | 'server' | 'persistent';
export type LaunchOptions = LaunchOptionsBase & { slowMo?: number }; export type LaunchOptions = LaunchOptionsBase & { slowMo?: number };
type LaunchServerOptions = LaunchOptionsBase & { port?: number }; type LaunchServerOptions = LaunchOptionsBase & { port?: number };
@ -73,6 +72,7 @@ export interface BrowserType {
} }
const mkdtempAsync = util.promisify(fs.mkdtemp); const mkdtempAsync = util.promisify(fs.mkdtemp);
const DOWNLOADS_FOLDER = path.join(os.tmpdir(), 'playwright_downloads-');
export abstract class BrowserTypeBase implements BrowserType { export abstract class BrowserTypeBase implements BrowserType {
private _name: string; private _name: string;
@ -100,24 +100,37 @@ export abstract class BrowserTypeBase implements BrowserType {
async launch(options: LaunchOptions = {}): Promise<Browser> { async launch(options: LaunchOptions = {}): Promise<Browser> {
assert(!(options as any).userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead'); assert(!(options as any).userDataDir, 'userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead');
return this._innerLaunch('local', options, undefined); assert(!(options as any).port, 'Cannot specify a port without launching as a server.');
return this._innerLaunch(options, undefined);
} }
async launchPersistentContext(userDataDir: string, options: LaunchOptions & PersistentContextOptions = {}): Promise<BrowserContext> { async launchPersistentContext(userDataDir: string, options: LaunchOptions & PersistentContextOptions = {}): Promise<BrowserContext> {
assert(!(options as any).port, 'Cannot specify a port without launching as a server.');
const persistent = validatePersistentContextOptions(options); const persistent = validatePersistentContextOptions(options);
const browser = await this._innerLaunch('persistent', options, persistent, userDataDir); const browser = await this._innerLaunch(options, persistent, userDataDir);
return browser._defaultContext!; return browser._defaultContext!;
} }
async _innerLaunch(launchType: LaunchType, options: LaunchOptions, persistent: PersistentContextOptions | undefined, userDataDir?: string): Promise<BrowserBase> { async _innerLaunch(options: LaunchOptions, persistent: PersistentContextOptions | undefined, userDataDir?: string): Promise<BrowserBase> {
const deadline = TimeoutSettings.computeDeadline(options.timeout, 30000); const deadline = TimeoutSettings.computeDeadline(options.timeout, 30000);
const logger = new RootLogger(options.logger); const logger = new RootLogger(options.logger);
logger.startLaunchRecording(); logger.startLaunchRecording();
let browserServer: BrowserServer | undefined; let browserServer: BrowserServer | undefined;
try { try {
browserServer = await this._launchServer(options, launchType, logger, deadline, userDataDir); const launched = await this._launchServer(options, !!persistent, logger, deadline, userDataDir);
const promise = this._innerLaunchPromise(browserServer, options, persistent); browserServer = launched.browserServer;
const browserOptions: BrowserOptions = {
slowMo: options.slowMo,
persistent,
headful: !processBrowserArgOptions(options).headless,
logger,
downloadsPath: launched.downloadsPath,
ownedServer: browserServer,
};
copyTestHooks(options, browserOptions);
const hasCustomArguments = !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs);
const promise = this._innerCreateBrowser(launched.transport, browserOptions, hasCustomArguments);
const browser = await helper.waitWithDeadline(promise, 'the browser to launch', deadline, 'pw:browser*'); const browser = await helper.waitWithDeadline(promise, 'the browser to launch', deadline, 'pw:browser*');
return browser; return browser;
} catch (e) { } catch (e) {
@ -132,34 +145,23 @@ export abstract class BrowserTypeBase implements BrowserType {
} }
} }
async _innerLaunchPromise(browserServer: BrowserServer, options: LaunchOptions, persistent: PersistentContextOptions | undefined): Promise<BrowserBase> { async _innerCreateBrowser(transport: ConnectionTransport, browserOptions: BrowserOptions, hasCustomArguments: boolean): Promise<BrowserBase> {
if ((options as any).__testHookBeforeCreateBrowser) if ((browserOptions as any).__testHookBeforeCreateBrowser)
await (options as any).__testHookBeforeCreateBrowser(); await (browserOptions as any).__testHookBeforeCreateBrowser();
const browser = await this._connectToTransport(transport, browserOptions);
const browserOptions: BrowserOptions = { // We assume no control when using custom arguments, and do not prepare the default context in that case.
slowMo: options.slowMo, if (browserOptions.persistent && !hasCustomArguments)
persistent, await browser._defaultContext!._loadDefaultContext();
headful: browserServer._headful,
logger: browserServer._logger,
downloadsPath: browserServer._downloadsPath,
ownedServer: browserServer,
};
for (const [key, value] of Object.entries(options)) {
if (key.startsWith('__testHook'))
(browserOptions as any)[key] = value;
}
const browser = await this._connectToTransport(browserServer._transport, browserOptions);
if (persistent && (!options.ignoreDefaultArgs || Array.isArray(options.ignoreDefaultArgs))) {
const context = browser._defaultContext!;
await context._loadDefaultContext();
}
return browser; return browser;
} }
async launchServer(options: LaunchServerOptions = {}): Promise<BrowserServer> { async launchServer(options: LaunchServerOptions = {}): Promise<BrowserServer> {
assert(!(options as any).userDataDir, 'userDataDir option is not supported in `browserType.launchServer`. Use `browserType.launchPersistentContext` instead');
const { port = 0 } = options;
const logger = new RootLogger(options.logger); const logger = new RootLogger(options.logger);
return this._launchServer(options, 'server', logger, TimeoutSettings.computeDeadline(options.timeout, 30000)); const { browserServer, transport } = await this._launchServer(options, false, logger, TimeoutSettings.computeDeadline(options.timeout, 30000));
browserServer._webSocketWrapper = this._wrapTransportWithWebSocket(transport, logger, port);
return browserServer;
} }
async connect(options: ConnectOptions): Promise<Browser> { async connect(options: ConnectOptions): Promise<Browser> {
@ -170,7 +172,12 @@ export abstract class BrowserTypeBase implements BrowserType {
let transport: ConnectionTransport | undefined; let transport: ConnectionTransport | undefined;
try { try {
transport = await WebSocketTransport.connect(options.wsEndpoint, logger, deadline); transport = await WebSocketTransport.connect(options.wsEndpoint, logger, deadline);
const promise = this._innerConnectPromise(transport, options, logger); const browserOptions: BrowserOptions = {
slowMo: options.slowMo,
logger,
};
copyTestHooks(options, browserOptions);
const promise = this._innerCreateBrowser(transport, browserOptions, false);
const browser = await helper.waitWithDeadline(promise, 'connect to browser', deadline, 'pw:browser*'); const browser = await helper.waitWithDeadline(promise, 'connect to browser', deadline, 'pw:browser*');
logger.stopLaunchRecording(); logger.stopLaunchRecording();
return browser; return browser;
@ -189,13 +196,7 @@ export abstract class BrowserTypeBase implements BrowserType {
} }
} }
async _innerConnectPromise(transport: ConnectionTransport, options: ConnectOptions, logger: RootLogger): Promise<Browser> { private async _launchServer(options: LaunchServerOptions, isPersistent: boolean, logger: RootLogger, deadline: number, userDataDir?: string): Promise<{ browserServer: BrowserServer, downloadsPath: string, transport: ConnectionTransport }> {
if ((options as any).__testHookBeforeCreateBrowser)
await (options as any).__testHookBeforeCreateBrowser();
return this._connectToTransport(transport, { slowMo: options.slowMo, logger });
}
private async _launchServer(options: LaunchServerOptions, launchType: LaunchType, logger: RootLogger, deadline: number, userDataDir?: string): Promise<BrowserServer> {
const { const {
ignoreDefaultArgs = false, ignoreDefaultArgs = false,
args = [], args = [],
@ -204,21 +205,20 @@ export abstract class BrowserTypeBase implements BrowserType {
handleSIGINT = true, handleSIGINT = true,
handleSIGTERM = true, handleSIGTERM = true,
handleSIGHUP = true, handleSIGHUP = true,
port = 0,
} = options; } = options;
assert(!port || launchType === 'server', 'Cannot specify a port without launching as a server.');
let temporaryUserDataDir: string | null = null; const downloadsPath = await mkdtempAsync(DOWNLOADS_FOLDER);
const tempDirectories = [downloadsPath];
if (!userDataDir) { if (!userDataDir) {
userDataDir = await mkdtempAsync(path.join(os.tmpdir(), `playwright_${this._name}dev_profile-`)); userDataDir = await mkdtempAsync(path.join(os.tmpdir(), `playwright_${this._name}dev_profile-`));
temporaryUserDataDir = userDataDir; tempDirectories.push(userDataDir);
} }
const browserArguments = []; const browserArguments = [];
if (!ignoreDefaultArgs) if (!ignoreDefaultArgs)
browserArguments.push(...this._defaultArgs(options, launchType, userDataDir)); browserArguments.push(...this._defaultArgs(options, isPersistent, userDataDir));
else if (Array.isArray(ignoreDefaultArgs)) else if (Array.isArray(ignoreDefaultArgs))
browserArguments.push(...this._defaultArgs(options, launchType, userDataDir).filter(arg => ignoreDefaultArgs.indexOf(arg) === -1)); browserArguments.push(...this._defaultArgs(options, isPersistent, userDataDir).filter(arg => ignoreDefaultArgs.indexOf(arg) === -1));
else else
browserArguments.push(...args); browserArguments.push(...args);
@ -230,7 +230,7 @@ export abstract class BrowserTypeBase implements BrowserType {
// "Cannot access 'browserServer' before initialization" if something went wrong. // "Cannot access 'browserServer' before initialization" if something went wrong.
let transport: ConnectionTransport | undefined = undefined; let transport: ConnectionTransport | undefined = undefined;
let browserServer: BrowserServer | undefined = undefined; let browserServer: BrowserServer | undefined = undefined;
const { launchedProcess, gracefullyClose, downloadsPath } = await launchProcess({ const { launchedProcess, gracefullyClose } = await launchProcess({
executablePath: executable, executablePath: executable,
args: browserArguments, args: browserArguments,
env: this._amendEnvironment(env, userDataDir, executable, browserArguments), env: this._amendEnvironment(env, userDataDir, executable, browserArguments),
@ -239,7 +239,7 @@ export abstract class BrowserTypeBase implements BrowserType {
handleSIGHUP, handleSIGHUP,
logger, logger,
pipe: !this._webSocketRegexNotPipe, pipe: !this._webSocketRegexNotPipe,
tempDir: temporaryUserDataDir || undefined, tempDirectories,
attemptToGracefullyClose: async () => { attemptToGracefullyClose: async () => {
if ((options as any).__testHookGracefullyClose) if ((options as any).__testHookGracefullyClose)
await (options as any).__testHookGracefullyClose(); await (options as any).__testHookGracefullyClose();
@ -269,14 +269,20 @@ export abstract class BrowserTypeBase implements BrowserType {
helper.killProcess(launchedProcess); helper.killProcess(launchedProcess);
throw e; throw e;
} }
browserServer = new BrowserServer(options, launchedProcess, gracefullyClose, transport, downloadsPath, browserServer = new BrowserServer(launchedProcess, gracefullyClose);
launchType === 'server' ? this._wrapTransportWithWebSocket(transport, logger, port) : null); return { browserServer, downloadsPath, transport };
return browserServer;
} }
abstract _defaultArgs(options: BrowserArgOptions, launchType: LaunchType, userDataDir: string): string[]; abstract _defaultArgs(options: BrowserArgOptions, isPersistent: boolean, userDataDir: string): string[];
abstract _connectToTransport(transport: ConnectionTransport, options: BrowserOptions): Promise<BrowserBase>; abstract _connectToTransport(transport: ConnectionTransport, options: BrowserOptions): Promise<BrowserBase>;
abstract _wrapTransportWithWebSocket(transport: ConnectionTransport, logger: InnerLogger, port: number): WebSocketWrapper; abstract _wrapTransportWithWebSocket(transport: ConnectionTransport, logger: InnerLogger, port: number): WebSocketWrapper;
abstract _amendEnvironment(env: Env, userDataDir: string, executable: string, browserArguments: string[]): Env; abstract _amendEnvironment(env: Env, userDataDir: string, executable: string, browserArguments: string[]): Env;
abstract _attemptToGracefullyCloseBrowser(transport: ConnectionTransport): void; abstract _attemptToGracefullyCloseBrowser(transport: ConnectionTransport): void;
} }
function copyTestHooks(from: object, to: object) {
for (const [key, value] of Object.entries(from)) {
if (key.startsWith('__testHook'))
(to as any)[key] = value;
}
}

6
src/server/chromium.ts
View file

@ -21,7 +21,7 @@ import { CRBrowser } from '../chromium/crBrowser';
import * as ws from 'ws'; import * as ws from 'ws';
import { Env } from './processLauncher'; import { Env } from './processLauncher';
import { kBrowserCloseMessageId } from '../chromium/crConnection'; import { kBrowserCloseMessageId } from '../chromium/crConnection';
import { BrowserArgOptions, BrowserTypeBase, processBrowserArgOptions, LaunchType } from './browserType'; import { BrowserArgOptions, BrowserTypeBase, processBrowserArgOptions } from './browserType';
import { WebSocketWrapper } from './browserServer'; import { WebSocketWrapper } from './browserServer';
import { ConnectionTransport, ProtocolRequest } from '../transport'; import { ConnectionTransport, ProtocolRequest } from '../transport';
import { InnerLogger, logError } from '../logger'; import { InnerLogger, logError } from '../logger';
@ -66,7 +66,7 @@ export class Chromium extends BrowserTypeBase {
return wrapTransportWithWebSocket(transport, logger, port); return wrapTransportWithWebSocket(transport, logger, port);
} }
_defaultArgs(options: BrowserArgOptions, launchType: LaunchType, userDataDir: string): string[] { _defaultArgs(options: BrowserArgOptions, isPersistent: boolean, userDataDir: string): string[] {
const { devtools, headless } = processBrowserArgOptions(options); const { devtools, headless } = processBrowserArgOptions(options);
const { args = [] } = options; const { args = [] } = options;
const userDataDirArg = args.find(arg => arg.startsWith('--user-data-dir')); const userDataDirArg = args.find(arg => arg.startsWith('--user-data-dir'));
@ -89,7 +89,7 @@ export class Chromium extends BrowserTypeBase {
); );
} }
chromeArguments.push(...args); chromeArguments.push(...args);
if (launchType === 'persistent') if (isPersistent)
chromeArguments.push('about:blank'); chromeArguments.push('about:blank');
else else
chromeArguments.push('--no-startup-window'); chromeArguments.push('--no-startup-window');

4
src/server/electron.ts
View file

@ -183,7 +183,7 @@ export class Electron {
logger, logger,
pipe: true, pipe: true,
cwd: options.cwd, cwd: options.cwd,
omitDownloads: true, tempDirectories: [],
attemptToGracefullyClose: () => app!.close(), attemptToGracefullyClose: () => app!.close(),
onkill: (exitCode, signal) => { onkill: (exitCode, signal) => {
if (app) if (app)
@ -198,7 +198,7 @@ export class Electron {
const chromeMatch = await waitForLine(launchedProcess, launchedProcess.stderr, /^DevTools listening on (ws:\/\/.*)$/, helper.timeUntilDeadline(deadline), timeoutError); const chromeMatch = await waitForLine(launchedProcess, launchedProcess.stderr, /^DevTools listening on (ws:\/\/.*)$/, helper.timeUntilDeadline(deadline), timeoutError);
const chromeTransport = await WebSocketTransport.connect(chromeMatch[1], logger, deadline); const chromeTransport = await WebSocketTransport.connect(chromeMatch[1], logger, deadline);
const browserServer = new BrowserServer(options, launchedProcess, gracefullyClose, chromeTransport, undefined, null); const browserServer = new BrowserServer(launchedProcess, gracefullyClose);
const browser = await CRBrowser.connect(chromeTransport, { headful: true, logger, persistent: { viewport: null }, ownedServer: browserServer }); const browser = await CRBrowser.connect(chromeTransport, { headful: true, logger, persistent: { viewport: null }, ownedServer: browserServer });
app = new ElectronApplication(logger, browser, nodeConnection); app = new ElectronApplication(logger, browser, nodeConnection);
await app._init(); await app._init();

6
src/server/firefox.ts
View file

@ -22,7 +22,7 @@ import { FFBrowser } from '../firefox/ffBrowser';
import { kBrowserCloseMessageId } from '../firefox/ffConnection'; import { kBrowserCloseMessageId } from '../firefox/ffConnection';
import { helper } from '../helper'; import { helper } from '../helper';
import { WebSocketWrapper } from './browserServer'; import { WebSocketWrapper } from './browserServer';
import { BrowserArgOptions, BrowserTypeBase, processBrowserArgOptions, LaunchType } from './browserType'; import { BrowserArgOptions, BrowserTypeBase, processBrowserArgOptions } from './browserType';
import { Env } from './processLauncher'; import { Env } from './processLauncher';
import { ConnectionTransport, SequenceNumberMixer } from '../transport'; import { ConnectionTransport, SequenceNumberMixer } from '../transport';
import { InnerLogger, logError } from '../logger'; import { InnerLogger, logError } from '../logger';
@ -56,7 +56,7 @@ export class Firefox extends BrowserTypeBase {
return wrapTransportWithWebSocket(transport, logger, port); return wrapTransportWithWebSocket(transport, logger, port);
} }
_defaultArgs(options: BrowserArgOptions, launchType: LaunchType, userDataDir: string): string[] { _defaultArgs(options: BrowserArgOptions, isPersistent: boolean, userDataDir: string): string[] {
const { devtools, headless } = processBrowserArgOptions(options); const { devtools, headless } = processBrowserArgOptions(options);
const { args = [] } = options; const { args = [] } = options;
if (devtools) if (devtools)
@ -77,7 +77,7 @@ export class Firefox extends BrowserTypeBase {
firefoxArguments.push(`-profile`, userDataDir); firefoxArguments.push(`-profile`, userDataDir);
firefoxArguments.push('-juggler', '0'); firefoxArguments.push('-juggler', '0');
firefoxArguments.push(...args); firefoxArguments.push(...args);
if (launchType === 'persistent') if (isPersistent)
firefoxArguments.push('about:blank'); firefoxArguments.push('about:blank');
else else
firefoxArguments.push('-silent'); firefoxArguments.push('-silent');

42
src/server/processLauncher.ts
View file

@ -17,9 +17,6 @@
import * as childProcess from 'child_process'; import * as childProcess from 'child_process';
import { Log, RootLogger } from '../logger'; import { Log, RootLogger } from '../logger';
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import * as readline from 'readline'; import * as readline from 'readline';
import * as removeFolder from 'rimraf'; import * as removeFolder from 'rimraf';
import * as stream from 'stream'; import * as stream from 'stream';
@ -28,8 +25,6 @@ import { TimeoutError } from '../errors';
import { helper } from '../helper'; import { helper } from '../helper';
const removeFolderAsync = util.promisify(removeFolder); const removeFolderAsync = util.promisify(removeFolder);
const mkdtempAsync = util.promisify(fs.mkdtemp);
const DOWNLOADS_FOLDER = path.join(os.tmpdir(), 'playwright_downloads-');
const browserLog: Log = { const browserLog: Log = {
name: 'browser', name: 'browser',
@ -55,10 +50,9 @@ export type LaunchProcessOptions = {
handleSIGTERM?: boolean, handleSIGTERM?: boolean,
handleSIGHUP?: boolean, handleSIGHUP?: boolean,
pipe?: boolean, pipe?: boolean,
tempDir?: string, tempDirectories: string[],
cwd?: string, cwd?: string,
omitDownloads?: boolean,
// Note: attemptToGracefullyClose should reject if it does not close the browser. // Note: attemptToGracefullyClose should reject if it does not close the browser.
attemptToGracefullyClose: () => Promise<any>, attemptToGracefullyClose: () => Promise<any>,
@ -69,10 +63,15 @@ export type LaunchProcessOptions = {
type LaunchResult = { type LaunchResult = {
launchedProcess: childProcess.ChildProcess, launchedProcess: childProcess.ChildProcess,
gracefullyClose: () => Promise<void>, gracefullyClose: () => Promise<void>,
downloadsPath: string
}; };
export async function launchProcess(options: LaunchProcessOptions): Promise<LaunchResult> { export async function launchProcess(options: LaunchProcessOptions): Promise<LaunchResult> {
const cleanup = async () => {
await Promise.all(options.tempDirectories.map(dir => {
return removeFolderAsync(dir).catch((err: Error) => console.error(err));
}));
};
const logger = options.logger; const logger = options.logger;
const stdio: ('ignore' | 'pipe')[] = options.pipe ? ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe']; const stdio: ('ignore' | 'pipe')[] = options.pipe ? ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'];
logger._log(browserLog, `<launching> ${options.executablePath} ${options.args.join(' ')}`); logger._log(browserLog, `<launching> ${options.executablePath} ${options.args.join(' ')}`);
@ -90,12 +89,12 @@ export async function launchProcess(options: LaunchProcessOptions): Promise<Laun
} }
); );
if (!spawnedProcess.pid) { if (!spawnedProcess.pid) {
let reject: (e: Error) => void; let failed: (e: Error) => void;
const result = new Promise<LaunchResult>((f, r) => reject = r); const failedPromise = new Promise<Error>((f, r) => failed = f);
spawnedProcess.once('error', error => { spawnedProcess.once('error', error => {
reject(new Error('Failed to launch browser: ' + error)); failed(new Error('Failed to launch browser: ' + error));
}); });
return result; return cleanup().then(() => failedPromise).then(e => Promise.reject(e));
} }
logger._log(browserLog, `<launched> pid=${spawnedProcess.pid}`); logger._log(browserLog, `<launched> pid=${spawnedProcess.pid}`);
@ -109,8 +108,6 @@ export async function launchProcess(options: LaunchProcessOptions): Promise<Laun
logger._log(browserStdErrLog, data); logger._log(browserStdErrLog, data);
}); });
const downloadsPath = options.omitDownloads ? '' : await mkdtempAsync(DOWNLOADS_FOLDER);
let processClosed = false; let processClosed = false;
let fulfillClose = () => {}; let fulfillClose = () => {};
const waitForClose = new Promise(f => fulfillClose = f); const waitForClose = new Promise(f => fulfillClose = f);
@ -122,11 +119,8 @@ export async function launchProcess(options: LaunchProcessOptions): Promise<Laun
helper.removeEventListeners(listeners); helper.removeEventListeners(listeners);
options.onkill(exitCode, signal); options.onkill(exitCode, signal);
fulfillClose(); fulfillClose();
// Cleanup as processes exit. // Cleanup as process exits.
Promise.all([ cleanup().then(fulfillCleanup);
options.omitDownloads ? Promise.resolve() : removeFolderAsync(downloadsPath),
options.tempDir ? removeFolderAsync(options.tempDir) : Promise.resolve()
]).catch((err: Error) => console.error(err)).then(fulfillCleanup);
}); });
const listeners = [ helper.addEventListener(process, 'exit', killProcess) ]; const listeners = [ helper.addEventListener(process, 'exit', killProcess) ];
@ -174,16 +168,14 @@ export async function launchProcess(options: LaunchProcessOptions): Promise<Laun
// the process might have already stopped // the process might have already stopped
} }
} }
// Attempt to remove temporary directories to avoid littering.
try { try {
if (options.tempDir) // Attempt to remove temporary directories to avoid littering.
removeFolder.sync(options.tempDir); for (const dir of options.tempDirectories)
if (!options.omitDownloads) removeFolder.sync(dir);
removeFolder.sync(downloadsPath);
} catch (e) { } } catch (e) { }
} }
return { launchedProcess: spawnedProcess, gracefullyClose, downloadsPath }; return { launchedProcess: spawnedProcess, gracefullyClose };
} }
export function waitForLine(process: childProcess.ChildProcess, inputStream: stream.Readable, regex: RegExp, timeout: number, timeoutError: TimeoutError): Promise<RegExpMatchArray> { export function waitForLine(process: childProcess.ChildProcess, inputStream: stream.Readable, regex: RegExp, timeout: number, timeoutError: TimeoutError): Promise<RegExpMatchArray> {

8
src/server/webkit.ts
View file

@ -20,7 +20,7 @@ import { Env } from './processLauncher';
import * as path from 'path'; import * as path from 'path';
import { helper } from '../helper'; import { helper } from '../helper';
import { kBrowserCloseMessageId } from '../webkit/wkConnection'; import { kBrowserCloseMessageId } from '../webkit/wkConnection';
import { BrowserArgOptions, BrowserTypeBase, processBrowserArgOptions, LaunchType } from './browserType'; import { BrowserArgOptions, BrowserTypeBase, processBrowserArgOptions } from './browserType';
import { ConnectionTransport, SequenceNumberMixer } from '../transport'; import { ConnectionTransport, SequenceNumberMixer } from '../transport';
import * as ws from 'ws'; import * as ws from 'ws';
import { WebSocketWrapper } from './browserServer'; import { WebSocketWrapper } from './browserServer';
@ -49,7 +49,7 @@ export class WebKit extends BrowserTypeBase {
return wrapTransportWithWebSocket(transport, logger, port); return wrapTransportWithWebSocket(transport, logger, port);
} }
_defaultArgs(options: BrowserArgOptions, launchType: LaunchType, userDataDir: string): string[] { _defaultArgs(options: BrowserArgOptions, isPersistent: boolean, userDataDir: string): string[] {
const { devtools, headless } = processBrowserArgOptions(options); const { devtools, headless } = processBrowserArgOptions(options);
const { args = [] } = options; const { args = [] } = options;
if (devtools) if (devtools)
@ -62,12 +62,12 @@ export class WebKit extends BrowserTypeBase {
const webkitArguments = ['--inspector-pipe']; const webkitArguments = ['--inspector-pipe'];
if (headless) if (headless)
webkitArguments.push('--headless'); webkitArguments.push('--headless');
if (launchType === 'persistent') if (isPersistent)
webkitArguments.push(`--user-data-dir=${userDataDir}`); webkitArguments.push(`--user-data-dir=${userDataDir}`);
else else
webkitArguments.push(`--no-startup-window`); webkitArguments.push(`--no-startup-window`);
webkitArguments.push(...args); webkitArguments.push(...args);
if (launchType === 'persistent') if (isPersistent)
webkitArguments.push('about:blank'); webkitArguments.push('about:blank');
return webkitArguments; return webkitArguments;
} }