/** * Copyright 2017 Google Inc. All rights reserved. * Modifications copyright (c) Microsoft Corporation. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import { WKBrowser } from '../webkit/wkBrowser'; import { PipeTransport } from './pipeTransport'; import { launchProcess } from './processLauncher'; import * as fs from 'fs'; import * as path from 'path'; import * as platform from '../platform'; import * as os from 'os'; import { helper } from '../helper'; import { kBrowserCloseMessageId } from '../webkit/wkConnection'; import { LaunchOptions, BrowserArgOptions, BrowserType } from './browserType'; import { ConnectionTransport, SequenceNumberMixer } from '../transport'; import * as ws from 'ws'; import { ConnectOptions, LaunchType } from '../browser'; import { BrowserServer } from './browserServer'; import { Events } from '../events'; import { BrowserContext } from '../browserContext'; export class WebKit implements BrowserType { private _executablePath: (string|undefined); executablePath(): string { if (!this._executablePath) throw new Error('No executable path!'); return this._executablePath; } name() { return 'webkit'; } async launch(options?: LaunchOptions & { slowMo?: number }): Promise { if (options && (options as any).userDataDir) throw new Error('userDataDir option is not supported in `browserType.launch`. Use `browserType.launchPersistentContext` instead'); const { browserServer, transport } = await this._launchServer(options, 'local'); const browser = await WKBrowser.connect(transport!, options && options.slowMo); (browser as any)['__server__'] = browserServer; return browser; } async launchServer(options?: LaunchOptions & { port?: number }): Promise { return (await this._launchServer(options, 'server', undefined, options && options.port)).browserServer; } async launchPersistentContext(userDataDir: string, options?: LaunchOptions): Promise { const { timeout = 30000 } = options || {}; const { transport } = await this._launchServer(options, 'persistent', userDataDir); const browser = await WKBrowser.connect(transport!, undefined, true); await helper.waitWithTimeout(browser._waitForFirstPageTarget(), 'first page', timeout); return browser._defaultContext; } private async _launchServer(options: LaunchOptions = {}, launchType: LaunchType, userDataDir?: string, port?: number): Promise<{ browserServer: BrowserServer, transport?: ConnectionTransport }> { const { ignoreDefaultArgs = false, args = [], dumpio = false, executablePath = null, env = process.env, handleSIGINT = true, handleSIGTERM = true, handleSIGHUP = true, } = options; let temporaryUserDataDir: string | null = null; if (!userDataDir) { userDataDir = await mkdtempAsync(WEBKIT_PROFILE_PATH); temporaryUserDataDir = userDataDir!; } const webkitArguments = []; if (!ignoreDefaultArgs) webkitArguments.push(...this._defaultArgs(options, launchType, userDataDir!, port || 0)); else if (Array.isArray(ignoreDefaultArgs)) webkitArguments.push(...this._defaultArgs(options, launchType, userDataDir!, port || 0).filter(arg => ignoreDefaultArgs.indexOf(arg) === -1)); else webkitArguments.push(...args); const webkitExecutable = executablePath || this._executablePath; if (!webkitExecutable) throw new Error(`No executable path is specified.`); const { launchedProcess, gracefullyClose } = await launchProcess({ executablePath: webkitExecutable, args: webkitArguments, env: { ...env, CURL_COOKIE_JAR_PATH: path.join(userDataDir!, 'cookiejar.db') }, handleSIGINT, handleSIGTERM, handleSIGHUP, dumpio, pipe: true, tempDir: temporaryUserDataDir || undefined, attemptToGracefullyClose: async () => { if (!transport) return Promise.reject(); // 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. transport.send({method: 'Playwright.close', params: {}, id: kBrowserCloseMessageId}); }, onkill: (exitCode, signal) => { if (browserServer) browserServer.emit(Events.BrowserServer.Close, exitCode, signal); }, }); // For local launch scenario close will terminate the browser process. let transport: ConnectionTransport | undefined = undefined; let browserServer: BrowserServer | undefined = undefined; transport = new PipeTransport(launchedProcess.stdio[3] as NodeJS.WritableStream, launchedProcess.stdio[4] as NodeJS.ReadableStream, () => browserServer!.close()); browserServer = new BrowserServer(launchedProcess, gracefullyClose, launchType === 'server' ? wrapTransportWithWebSocket(transport, port || 0) : null); return { browserServer, transport }; } async connect(options: ConnectOptions): Promise { return await platform.connectToWebsocket(options.wsEndpoint, transport => { return WKBrowser.connect(transport, options.slowMo); }); } _defaultArgs(options: BrowserArgOptions = {}, launchType: LaunchType, userDataDir: string, port: number): string[] { const { devtools = false, headless = !devtools, args = [], } = options; if (devtools) console.warn('devtools parameter as a launch argument in WebKit is not supported. Also starting Web Inspector manually will terminate the execution in WebKit.'); const userDataDirArg = args.find(arg => arg.startsWith('--user-data-dir=')); if (userDataDirArg) throw new Error('Pass userDataDir parameter instead of specifying --user-data-dir argument'); if (launchType !== 'persistent' && args.find(arg => !arg.startsWith('-'))) throw new Error('Arguments can not specify page to be opened'); const webkitArguments = ['--inspector-pipe']; if (headless) webkitArguments.push('--headless'); if (launchType === 'persistent') webkitArguments.push(`--user-data-dir=${userDataDir}`); else webkitArguments.push(`--no-startup-window`); webkitArguments.push(...args); return webkitArguments; } } const mkdtempAsync = platform.promisify(fs.mkdtemp); const WEBKIT_PROFILE_PATH = path.join(os.tmpdir(), 'playwright_dev_profile-'); function wrapTransportWithWebSocket(transport: ConnectionTransport, port: number): string { const server = new ws.Server({ port }); const guid = platform.guid(); const idMixer = new SequenceNumberMixer<{id: number, socket: ws}>(); const pendingBrowserContextCreations = new Set(); const pendingBrowserContextDeletions = new Map(); const browserContextIds = new Map(); const pageProxyIds = new Map(); const sockets = new Set(); transport.onmessage = message => { if (typeof message.id === 'number') { if (message.id === -9999) return; // Process command response. const value = idMixer.take(message.id); if (!value) return; const { id, socket } = value; if (socket.readyState === ws.CLOSING) { if (pendingBrowserContextCreations.has(id)) { transport.send({ id: ++SequenceNumberMixer._lastSequenceNumber, method: 'Playwright.deleteContext', params: { browserContextId: message.result.browserContextId } }); } return; } if (pendingBrowserContextCreations.has(message.id)) { // Browser.createContext response -> establish context attribution. browserContextIds.set(message.result.browserContextId, socket); pendingBrowserContextCreations.delete(message.id); } const deletedContextId = pendingBrowserContextDeletions.get(message.id); if (deletedContextId) { // Browser.deleteContext response -> remove context attribution. browserContextIds.delete(deletedContextId); pendingBrowserContextDeletions.delete(message.id); } message.id = id; socket.send(JSON.stringify(message)); return; } // Process notification response. const { method, params, pageProxyId } = message; if (pageProxyId) { const socket = pageProxyIds.get(pageProxyId); if (!socket || socket.readyState === ws.CLOSING) { // Drop unattributed messages on the floor. return; } socket.send(JSON.stringify(message)); return; } if (method === 'Playwright.pageProxyCreated') { const socket = browserContextIds.get(params.pageProxyInfo.browserContextId); if (!socket || socket.readyState === ws.CLOSING) { // Drop unattributed messages on the floor. return; } pageProxyIds.set(params.pageProxyInfo.pageProxyId, socket); socket.send(JSON.stringify(message)); return; } if (method === 'Playwright.pageProxyDestroyed') { const socket = pageProxyIds.get(params.pageProxyId); pageProxyIds.delete(params.pageProxyId); if (socket && socket.readyState !== ws.CLOSING) socket.send(JSON.stringify(message)); return; } if (method === 'Playwright.provisionalLoadFailed') { const socket = pageProxyIds.get(params.pageProxyId); if (socket && socket.readyState !== ws.CLOSING) socket.send(JSON.stringify(message)); return; } }; transport.onclose = () => { for (const socket of sockets) { socket.removeListener('close', (socket as any).__closeListener); socket.close(undefined, 'Browser disconnected'); } server.close(); transport.onmessage = undefined; transport.onclose = undefined; }; server.on('connection', (socket: ws, req) => { if (req.url !== '/' + guid) { socket.close(); return; } sockets.add(socket); socket.on('message', (message: string) => { const parsedMessage = JSON.parse(Buffer.from(message).toString()); const { id, method, params } = parsedMessage; const seqNum = idMixer.generate({ id, socket }); transport.send({ ...parsedMessage, id: seqNum }); if (method === 'Playwright.createContext') pendingBrowserContextCreations.add(seqNum); if (method === 'Playwright.deleteContext') pendingBrowserContextDeletions.set(seqNum, params.browserContextId); }); socket.on('close', (socket as any).__closeListener = () => { for (const [pageProxyId, s] of pageProxyIds) { if (s === socket) pageProxyIds.delete(pageProxyId); } for (const [browserContextId, s] of browserContextIds) { if (s === socket) { transport.send({ id: ++SequenceNumberMixer._lastSequenceNumber, method: 'Playwright.deleteContext', params: { browserContextId } }); browserContextIds.delete(browserContextId); } } sockets.delete(socket); }); }); const address = server.address(); if (typeof address === 'string') return address + '/' + guid; return 'ws://127.0.0.1:' + address.port + '/' + guid; }