| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you 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. | |
| /** | |
| * @fileoverview Defines an {@linkplain cmd.Executor command executor} that | |
| * communicates with a remote end using HTTP + JSON. | |
| */ | |
| 'use strict' | |
| const http = require('node:http') | |
| const https = require('node:https') | |
| const url = require('node:url') | |
| const httpLib = require('../lib/http') | |
| /** | |
| * @typedef {{protocol: (?string|undefined), | |
| * auth: (?string|undefined), | |
| * hostname: (?string|undefined), | |
| * host: (?string|undefined), | |
| * port: (?string|undefined), | |
| * path: (?string|undefined), | |
| * pathname: (?string|undefined)}} | |
| */ | |
| let RequestOptions // eslint-disable-line | |
| /** | |
| * @param {string} aUrl The request URL to parse. | |
| * @return {RequestOptions} The request options. | |
| * @throws {Error} if the URL does not include a hostname. | |
| */ | |
| function getRequestOptions(aUrl) { | |
| // eslint-disable-next-line n/no-deprecated-api | |
| let options = url.parse(aUrl) | |
| if (!options.hostname) { | |
| throw new Error('Invalid URL: ' + aUrl) | |
| } | |
| // Delete the search and has portions as they are not used. | |
| options.search = null | |
| options.hash = null | |
| options.path = options.pathname | |
| options.hostname = options.hostname === 'localhost' ? '127.0.0.1' : options.hostname // To support Node 17 and above. Refer https://github.com/nodejs/node/issues/40702 for details. | |
| return options | |
| } | |
| /** @const {string} */ | |
| const USER_AGENT = (function () { | |
| const version = require('../package.json').version | |
| const platform = { darwin: 'mac', win32: 'windows' }[process.platform] || 'linux' | |
| return `selenium/${version} (js ${platform})` | |
| })() | |
| /** | |
| * A basic HTTP client used to send messages to a remote end. | |
| * | |
| * @implements {httpLib.Client} | |
| */ | |
| class HttpClient { | |
| /** | |
| * @param {string} serverUrl URL for the WebDriver server to send commands to. | |
| * @param {http.Agent=} opt_agent The agent to use for each request. | |
| * Defaults to `http.globalAgent`. | |
| * @param {?string=} opt_proxy The proxy to use for the connection to the | |
| * server. Default is to use no proxy. | |
| * @param {?Object.<string,Object>} client_options | |
| */ | |
| constructor(serverUrl, opt_agent, opt_proxy, client_options = {}) { | |
| /** @private {http.Agent} */ | |
| this.agent_ = opt_agent || null | |
| /** | |
| * Base options for each request. | |
| * @private {RequestOptions} | |
| */ | |
| this.options_ = getRequestOptions(serverUrl) | |
| /** | |
| * client options, header overrides | |
| */ | |
| this.client_options = client_options | |
| /** | |
| * sets keep-alive for the agent | |
| * see https://stackoverflow.com/a/58332910 | |
| */ | |
| this.keepAlive = this.client_options['keep-alive'] | |
| /** @private {?RequestOptions} */ | |
| this.proxyOptions_ = opt_proxy ? getRequestOptions(opt_proxy) : null | |
| } | |
| get keepAlive() { | |
| return this.agent_.keepAlive | |
| } | |
| set keepAlive(value) { | |
| if (value === 'true' || value === true) { | |
| this.agent_.keepAlive = true | |
| } | |
| } | |
| /** @override */ | |
| send(httpRequest) { | |
| let data | |
| let headers = {} | |
| if (httpRequest.headers) { | |
| httpRequest.headers.forEach(function (value, name) { | |
| headers[name] = value | |
| }) | |
| } | |
| headers['User-Agent'] = this.client_options['user-agent'] || USER_AGENT | |
| headers['Content-Length'] = 0 | |
| if (httpRequest.method == 'POST' || httpRequest.method == 'PUT') { | |
| data = JSON.stringify(httpRequest.data) | |
| headers['Content-Length'] = Buffer.byteLength(data, 'utf8') | |
| headers['Content-Type'] = 'application/json;charset=UTF-8' | |
| } | |
| let path = this.options_.path | |
| if (path.endsWith('/') && httpRequest.path.startsWith('/')) { | |
| path += httpRequest.path.substring(1) | |
| } else { | |
| path += httpRequest.path | |
| } | |
| // eslint-disable-next-line n/no-deprecated-api | |
| let parsedPath = url.parse(path) | |
| let options = { | |
| agent: this.agent_ || null, | |
| method: httpRequest.method, | |
| auth: this.options_.auth, | |
| hostname: this.options_.hostname, | |
| port: this.options_.port, | |
| protocol: this.options_.protocol, | |
| path: parsedPath.path, | |
| pathname: parsedPath.pathname, | |
| search: parsedPath.search, | |
| hash: parsedPath.hash, | |
| headers, | |
| } | |
| return new Promise((fulfill, reject) => { | |
| sendRequest(options, fulfill, reject, data, this.proxyOptions_) | |
| }) | |
| } | |
| } | |
| /** | |
| * Sends a single HTTP request. | |
| * @param {!Object} options The request options. | |
| * @param {function(!httpLib.Response)} onOk The function to call if the | |
| * request succeeds. | |
| * @param {function(!Error)} onError The function to call if the request fails. | |
| * @param {?string=} opt_data The data to send with the request. | |
| * @param {?RequestOptions=} opt_proxy The proxy server to use for the request. | |
| * @param {number=} opt_retries The current number of retries. | |
| */ | |
| function sendRequest(options, onOk, onError, opt_data, opt_proxy, opt_retries) { | |
| var hostname = options.hostname | |
| var port = options.port | |
| if (opt_proxy) { | |
| let proxy = /** @type {RequestOptions} */ (opt_proxy) | |
| // RFC 2616, section 5.1.2: | |
| // The absoluteURI form is REQUIRED when the request is being made to a | |
| // proxy. | |
| let absoluteUri = url.format(options) | |
| // RFC 2616, section 14.23: | |
| // An HTTP/1.1 proxy MUST ensure that any request message it forwards does | |
| // contain an appropriate Host header field that identifies the service | |
| // being requested by the proxy. | |
| let targetHost = options.hostname | |
| if (options.port) { | |
| targetHost += ':' + options.port | |
| } | |
| // Update the request options with our proxy info. | |
| options.headers['Host'] = targetHost | |
| options.path = absoluteUri | |
| options.host = proxy.host | |
| options.hostname = proxy.hostname | |
| options.port = proxy.port | |
| // Update the protocol to avoid EPROTO errors when the webdriver proxy | |
| // uses a different protocol from the remote selenium server. | |
| options.protocol = opt_proxy.protocol | |
| if (proxy.auth) { | |
| options.headers['Proxy-Authorization'] = 'Basic ' + Buffer.from(proxy.auth).toString('base64') | |
| } | |
| } | |
| let requestFn = options.protocol === 'https:' ? https.request : http.request | |
| var request = requestFn(options, function onResponse(response) { | |
| if (response.statusCode == 302 || response.statusCode == 303) { | |
| let location | |
| try { | |
| // eslint-disable-next-line n/no-deprecated-api | |
| location = url.parse(response.headers['location']) | |
| } catch (ex) { | |
| onError( | |
| Error( | |
| 'Failed to parse "Location" header for server redirect: ' + | |
| ex.message + | |
| '\nResponse was: \n' + | |
| new httpLib.Response(response.statusCode, response.headers, ''), | |
| ), | |
| ) | |
| return | |
| } | |
| if (!location.hostname) { | |
| location.hostname = hostname | |
| location.port = port | |
| location.auth = options.auth | |
| } | |
| request.destroy() | |
| sendRequest( | |
| { | |
| method: 'GET', | |
| protocol: location.protocol || options.protocol, | |
| hostname: location.hostname, | |
| port: location.port, | |
| path: location.path, | |
| auth: location.auth, | |
| pathname: location.pathname, | |
| search: location.search, | |
| hash: location.hash, | |
| headers: { | |
| Accept: 'application/json; charset=utf-8', | |
| 'User-Agent': options.headers['User-Agent'] || USER_AGENT, | |
| }, | |
| }, | |
| onOk, | |
| onError, | |
| undefined, | |
| opt_proxy, | |
| ) | |
| return | |
| } | |
| const body = [] | |
| response.on('data', body.push.bind(body)) | |
| response.on('end', function () { | |
| const resp = new httpLib.Response( | |
| /** @type {number} */ (response.statusCode), | |
| /** @type {!Object<string>} */ (response.headers), | |
| Buffer.concat(body).toString('utf8').replace(/\0/g, ''), | |
| ) | |
| onOk(resp) | |
| }) | |
| }) | |
| request.on('error', function (e) { | |
| if (typeof opt_retries === 'undefined') { | |
| opt_retries = 0 | |
| } | |
| if (shouldRetryRequest(opt_retries, e)) { | |
| opt_retries += 1 | |
| setTimeout(function () { | |
| sendRequest(options, onOk, onError, opt_data, opt_proxy, opt_retries) | |
| }, 15) | |
| } else { | |
| let message = e.message | |
| if (e.code) { | |
| message = e.code + ' ' + message | |
| } | |
| onError(new Error(message)) | |
| } | |
| }) | |
| if (opt_data) { | |
| request.write(opt_data) | |
| } | |
| request.end() | |
| } | |
| const MAX_RETRIES = 3 | |
| /** | |
| * A retry is sometimes needed on Windows where we may quickly run out of | |
| * ephemeral ports. A more robust solution is bumping the MaxUserPort setting | |
| * as described here: http://msdn.microsoft.com/en-us/library/aa560610%28v=bts.20%29.aspx | |
| * | |
| * @param {!number} retries | |
| * @param {!Error} err | |
| * @return {boolean} | |
| */ | |
| function shouldRetryRequest(retries, err) { | |
| return retries < MAX_RETRIES && isRetryableNetworkError(err) | |
| } | |
| /** | |
| * @param {!Error} err | |
| * @return {boolean} | |
| */ | |
| function isRetryableNetworkError(err) { | |
| if (err && err.code) { | |
| return ( | |
| err.code === 'ECONNABORTED' || | |
| err.code === 'ECONNRESET' || | |
| err.code === 'ECONNREFUSED' || | |
| err.code === 'EADDRINUSE' || | |
| err.code === 'EPIPE' || | |
| err.code === 'ETIMEDOUT' | |
| ) | |
| } | |
| return false | |
| } | |
| // PUBLIC API | |
| module.exports.Agent = http.Agent | |
| module.exports.Executor = httpLib.Executor | |
| module.exports.HttpClient = HttpClient | |
| module.exports.Request = httpLib.Request | |
| module.exports.Response = httpLib.Response |