minigame

node_modules/selenium-webdriver/http/index.js

@@ -0,0 +1,346 @@
+// 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('http')
+const https = require('https')
+const url = require('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 node/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 node/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 node/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