Buckets:
| var net = require('net') | |
| , tls = require('tls') | |
| , http = require('http') | |
| , https = require('https') | |
| , events = require('events') | |
| , assert = require('assert') | |
| , util = require('util') | |
| , Buffer = require('safe-buffer').Buffer | |
| ; | |
| exports.httpOverHttp = httpOverHttp | |
| exports.httpsOverHttp = httpsOverHttp | |
| exports.httpOverHttps = httpOverHttps | |
| exports.httpsOverHttps = httpsOverHttps | |
| function httpOverHttp(options) { | |
| var agent = new TunnelingAgent(options) | |
| agent.request = http.request | |
| return agent | |
| } | |
| function httpsOverHttp(options) { | |
| var agent = new TunnelingAgent(options) | |
| agent.request = http.request | |
| agent.createSocket = createSecureSocket | |
| agent.defaultPort = 443 | |
| return agent | |
| } | |
| function httpOverHttps(options) { | |
| var agent = new TunnelingAgent(options) | |
| agent.request = https.request | |
| return agent | |
| } | |
| function httpsOverHttps(options) { | |
| var agent = new TunnelingAgent(options) | |
| agent.request = https.request | |
| agent.createSocket = createSecureSocket | |
| agent.defaultPort = 443 | |
| return agent | |
| } | |
| function TunnelingAgent(options) { | |
| var self = this | |
| self.options = options || {} | |
| self.proxyOptions = self.options.proxy || {} | |
| self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets | |
| self.requests = [] | |
| self.sockets = [] | |
| self.on('free', function onFree(socket, host, port) { | |
| for (var i = 0, len = self.requests.length; i < len; ++i) { | |
| var pending = self.requests[i] | |
| if (pending.host === host && pending.port === port) { | |
| // Detect the request to connect same origin server, | |
| // reuse the connection. | |
| self.requests.splice(i, 1) | |
| pending.request.onSocket(socket) | |
| return | |
| } | |
| } | |
| socket.destroy() | |
| self.removeSocket(socket) | |
| }) | |
| } | |
| util.inherits(TunnelingAgent, events.EventEmitter) | |
| TunnelingAgent.prototype.addRequest = function addRequest(req, options) { | |
| var self = this | |
| // Legacy API: addRequest(req, host, port, path) | |
| if (typeof options === 'string') { | |
| options = { | |
| host: options, | |
| port: arguments[2], | |
| path: arguments[3] | |
| }; | |
| } | |
| if (self.sockets.length >= this.maxSockets) { | |
| // We are over limit so we'll add it to the queue. | |
| self.requests.push({host: options.host, port: options.port, request: req}) | |
| return | |
| } | |
| // If we are under maxSockets create a new one. | |
| self.createConnection({host: options.host, port: options.port, request: req}) | |
| } | |
| TunnelingAgent.prototype.createConnection = function createConnection(pending) { | |
| var self = this | |
| self.createSocket(pending, function(socket) { | |
| socket.on('free', onFree) | |
| socket.on('close', onCloseOrRemove) | |
| socket.on('agentRemove', onCloseOrRemove) | |
| pending.request.onSocket(socket) | |
| function onFree() { | |
| self.emit('free', socket, pending.host, pending.port) | |
| } | |
| function onCloseOrRemove(err) { | |
| self.removeSocket(socket) | |
| socket.removeListener('free', onFree) | |
| socket.removeListener('close', onCloseOrRemove) | |
| socket.removeListener('agentRemove', onCloseOrRemove) | |
| } | |
| }) | |
| } | |
| TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { | |
| var self = this | |
| var placeholder = {} | |
| self.sockets.push(placeholder) | |
| var connectOptions = mergeOptions({}, self.proxyOptions, | |
| { method: 'CONNECT' | |
| , path: options.host + ':' + options.port | |
| , agent: false | |
| } | |
| ) | |
| if (connectOptions.proxyAuth) { | |
| connectOptions.headers = connectOptions.headers || {} | |
| connectOptions.headers['Proxy-Authorization'] = 'Basic ' + | |
| Buffer.from(connectOptions.proxyAuth).toString('base64') | |
| } | |
| debug('making CONNECT request') | |
| var connectReq = self.request(connectOptions) | |
| connectReq.useChunkedEncodingByDefault = false // for v0.6 | |
| connectReq.once('response', onResponse) // for v0.6 | |
| connectReq.once('upgrade', onUpgrade) // for v0.6 | |
| connectReq.once('connect', onConnect) // for v0.7 or later | |
| connectReq.once('error', onError) | |
| connectReq.end() | |
| function onResponse(res) { | |
| // Very hacky. This is necessary to avoid http-parser leaks. | |
| res.upgrade = true | |
| } | |
| function onUpgrade(res, socket, head) { | |
| // Hacky. | |
| process.nextTick(function() { | |
| onConnect(res, socket, head) | |
| }) | |
| } | |
| function onConnect(res, socket, head) { | |
| connectReq.removeAllListeners() | |
| socket.removeAllListeners() | |
| if (res.statusCode === 200) { | |
| assert.equal(head.length, 0) | |
| debug('tunneling connection has established') | |
| self.sockets[self.sockets.indexOf(placeholder)] = socket | |
| cb(socket) | |
| } else { | |
| debug('tunneling socket could not be established, statusCode=%d', res.statusCode) | |
| var error = new Error('tunneling socket could not be established, ' + 'statusCode=' + res.statusCode) | |
| error.code = 'ECONNRESET' | |
| options.request.emit('error', error) | |
| self.removeSocket(placeholder) | |
| } | |
| } | |
| function onError(cause) { | |
| connectReq.removeAllListeners() | |
| debug('tunneling socket could not be established, cause=%s\n', cause.message, cause.stack) | |
| var error = new Error('tunneling socket could not be established, ' + 'cause=' + cause.message) | |
| error.code = 'ECONNRESET' | |
| options.request.emit('error', error) | |
| self.removeSocket(placeholder) | |
| } | |
| } | |
| TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { | |
| var pos = this.sockets.indexOf(socket) | |
| if (pos === -1) return | |
| this.sockets.splice(pos, 1) | |
| var pending = this.requests.shift() | |
| if (pending) { | |
| // If we have pending requests and a socket gets closed a new one | |
| // needs to be created to take over in the pool for the one that closed. | |
| this.createConnection(pending) | |
| } | |
| } | |
| function createSecureSocket(options, cb) { | |
| var self = this | |
| TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { | |
| // 0 is dummy port for v0.6 | |
| var secureSocket = tls.connect(0, mergeOptions({}, self.options, | |
| { servername: options.host | |
| , socket: socket | |
| } | |
| )) | |
| self.sockets[self.sockets.indexOf(socket)] = secureSocket | |
| cb(secureSocket) | |
| }) | |
| } | |
| function mergeOptions(target) { | |
| for (var i = 1, len = arguments.length; i < len; ++i) { | |
| var overrides = arguments[i] | |
| if (typeof overrides === 'object') { | |
| var keys = Object.keys(overrides) | |
| for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { | |
| var k = keys[j] | |
| if (overrides[k] !== undefined) { | |
| target[k] = overrides[k] | |
| } | |
| } | |
| } | |
| } | |
| return target | |
| } | |
| var debug | |
| if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { | |
| debug = function() { | |
| var args = Array.prototype.slice.call(arguments) | |
| if (typeof args[0] === 'string') { | |
| args[0] = 'TUNNEL: ' + args[0] | |
| } else { | |
| args.unshift('TUNNEL:') | |
| } | |
| console.error.apply(console, args) | |
| } | |
| } else { | |
| debug = function() {} | |
| } | |
| exports.debug = debug // for test | |
Xet Storage Details
- Size:
- 6.88 kB
- Xet hash:
- 4949bcd9be074994df0aa25e30fc08b150d073263e685e8030bb4d0318e8faf6
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.