| 'use strict'; | |
| require('./patch-core'); | |
| const inherits = require('util').inherits; | |
| const promisify = require('es6-promisify'); | |
| const EventEmitter = require('events').EventEmitter; | |
| module.exports = Agent; | |
| function isAgent(v) { | |
| return v && typeof v.addRequest === 'function'; | |
| } | |
| /** | |
| * Base `http.Agent` implementation. | |
| * No pooling/keep-alive is implemented by default. | |
| * | |
| * @param {Function} callback | |
| * @api public | |
| */ | |
| function Agent(callback, _opts) { | |
| if (!(this instanceof Agent)) { | |
| return new Agent(callback, _opts); | |
| } | |
| EventEmitter.call(this); | |
| // The callback gets promisified if it has 3 parameters | |
| // (i.e. it has a callback function) lazily | |
| this._promisifiedCallback = false; | |
| let opts = _opts; | |
| if ('function' === typeof callback) { | |
| this.callback = callback; | |
| } else if (callback) { | |
| opts = callback; | |
| } | |
| // timeout for the socket to be returned from the callback | |
| this.timeout = (opts && opts.timeout) || null; | |
| this.options = opts; | |
| } | |
| inherits(Agent, EventEmitter); | |
| /** | |
| * Override this function in your subclass! | |
| */ | |
| Agent.prototype.callback = function callback(req, opts) { | |
| throw new Error( | |
| '"agent-base" has no default implementation, you must subclass and override `callback()`' | |
| ); | |
| }; | |
| /** | |
| * Called by node-core's "_http_client.js" module when creating | |
| * a new HTTP request with this Agent instance. | |
| * | |
| * @api public | |
| */ | |
| Agent.prototype.addRequest = function addRequest(req, _opts) { | |
| const ownOpts = Object.assign({}, _opts); | |
| // Set default `host` for HTTP to localhost | |
| if (null == ownOpts.host) { | |
| ownOpts.host = 'localhost'; | |
| } | |
| // Set default `port` for HTTP if none was explicitly specified | |
| if (null == ownOpts.port) { | |
| ownOpts.port = ownOpts.secureEndpoint ? 443 : 80; | |
| } | |
| const opts = Object.assign({}, this.options, ownOpts); | |
| if (opts.host && opts.path) { | |
| // If both a `host` and `path` are specified then it's most likely the | |
| // result of a `url.parse()` call... we need to remove the `path` portion so | |
| // that `net.connect()` doesn't attempt to open that as a unix socket file. | |
| delete opts.path; | |
| } | |
| delete opts.agent; | |
| delete opts.hostname; | |
| delete opts._defaultAgent; | |
| delete opts.defaultPort; | |
| delete opts.createConnection; | |
| // Hint to use "Connection: close" | |
| // XXX: non-documented `http` module API :( | |
| req._last = true; | |
| req.shouldKeepAlive = false; | |
| // Create the `stream.Duplex` instance | |
| let timeout; | |
| let timedOut = false; | |
| const timeoutMs = this.timeout; | |
| const freeSocket = this.freeSocket; | |
| function onerror(err) { | |
| if (req._hadError) return; | |
| req.emit('error', err); | |
| // For Safety. Some additional errors might fire later on | |
| // and we need to make sure we don't double-fire the error event. | |
| req._hadError = true; | |
| } | |
| function ontimeout() { | |
| timeout = null; | |
| timedOut = true; | |
| const err = new Error( | |
| 'A "socket" was not created for HTTP request before ' + timeoutMs + 'ms' | |
| ); | |
| err.code = 'ETIMEOUT'; | |
| onerror(err); | |
| } | |
| function callbackError(err) { | |
| if (timedOut) return; | |
| if (timeout != null) { | |
| clearTimeout(timeout); | |
| timeout = null; | |
| } | |
| onerror(err); | |
| } | |
| function onsocket(socket) { | |
| if (timedOut) return; | |
| if (timeout != null) { | |
| clearTimeout(timeout); | |
| timeout = null; | |
| } | |
| if (isAgent(socket)) { | |
| // `socket` is actually an http.Agent instance, so relinquish | |
| // responsibility for this `req` to the Agent from here on | |
| socket.addRequest(req, opts); | |
| } else if (socket) { | |
| function onfree() { | |
| freeSocket(socket, opts); | |
| } | |
| socket.on('free', onfree); | |
| req.onSocket(socket); | |
| } else { | |
| const err = new Error( | |
| 'no Duplex stream was returned to agent-base for `' + req.method + ' ' + req.path + '`' | |
| ); | |
| onerror(err); | |
| } | |
| } | |
| if (!this._promisifiedCallback && this.callback.length >= 3) { | |
| // Legacy callback function - convert to a Promise | |
| this.callback = promisify(this.callback, this); | |
| this._promisifiedCallback = true; | |
| } | |
| if (timeoutMs > 0) { | |
| timeout = setTimeout(ontimeout, timeoutMs); | |
| } | |
| try { | |
| Promise.resolve(this.callback(req, opts)).then(onsocket, callbackError); | |
| } catch (err) { | |
| Promise.reject(err).catch(callbackError); | |
| } | |
| }; | |
| Agent.prototype.freeSocket = function freeSocket(socket, opts) { | |
| // TODO reuse sockets | |
| socket.destroy(); | |
| }; |