196 lines
3.6 KiB
JavaScript
196 lines
3.6 KiB
JavaScript
/*!
|
|
* on-finished
|
|
* Copyright(c) 2013 Jonathan Ong
|
|
* Copyright(c) 2014 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
'use strict'
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
module.exports = onFinished
|
|
module.exports.isFinished = isFinished
|
|
|
|
/**
|
|
* Module dependencies.
|
|
* @private
|
|
*/
|
|
|
|
var first = require('ee-first')
|
|
|
|
/**
|
|
* Variables.
|
|
* @private
|
|
*/
|
|
|
|
/* istanbul ignore next */
|
|
var defer = typeof setImmediate === 'function'
|
|
? setImmediate
|
|
: function(fn){ process.nextTick(fn.bind.apply(fn, arguments)) }
|
|
|
|
/**
|
|
* Invoke callback when the response has finished, useful for
|
|
* cleaning up resources afterwards.
|
|
*
|
|
* @param {object} msg
|
|
* @param {function} listener
|
|
* @return {object}
|
|
* @public
|
|
*/
|
|
|
|
function onFinished(msg, listener) {
|
|
if (isFinished(msg) !== false) {
|
|
defer(listener, null, msg)
|
|
return msg
|
|
}
|
|
|
|
// attach the listener to the message
|
|
attachListener(msg, listener)
|
|
|
|
return msg
|
|
}
|
|
|
|
/**
|
|
* Determine if message is already finished.
|
|
*
|
|
* @param {object} msg
|
|
* @return {boolean}
|
|
* @public
|
|
*/
|
|
|
|
function isFinished(msg) {
|
|
var socket = msg.socket
|
|
|
|
if (typeof msg.finished === 'boolean') {
|
|
// OutgoingMessage
|
|
return Boolean(msg.finished || (socket && !socket.writable))
|
|
}
|
|
|
|
if (typeof msg.complete === 'boolean') {
|
|
// IncomingMessage
|
|
return Boolean(msg.upgrade || !socket || !socket.readable || (msg.complete && !msg.readable))
|
|
}
|
|
|
|
// don't know
|
|
return undefined
|
|
}
|
|
|
|
/**
|
|
* Attach a finished listener to the message.
|
|
*
|
|
* @param {object} msg
|
|
* @param {function} callback
|
|
* @private
|
|
*/
|
|
|
|
function attachFinishedListener(msg, callback) {
|
|
var eeMsg
|
|
var eeSocket
|
|
var finished = false
|
|
|
|
function onFinish(error) {
|
|
eeMsg.cancel()
|
|
eeSocket.cancel()
|
|
|
|
finished = true
|
|
callback(error)
|
|
}
|
|
|
|
// finished on first message event
|
|
eeMsg = eeSocket = first([[msg, 'end', 'finish']], onFinish)
|
|
|
|
function onSocket(socket) {
|
|
// remove listener
|
|
msg.removeListener('socket', onSocket)
|
|
|
|
if (finished) return
|
|
if (eeMsg !== eeSocket) return
|
|
|
|
// finished on first socket event
|
|
eeSocket = first([[socket, 'error', 'close']], onFinish)
|
|
}
|
|
|
|
if (msg.socket) {
|
|
// socket already assigned
|
|
onSocket(msg.socket)
|
|
return
|
|
}
|
|
|
|
// wait for socket to be assigned
|
|
msg.on('socket', onSocket)
|
|
|
|
if (msg.socket === undefined) {
|
|
// node.js 0.8 patch
|
|
patchAssignSocket(msg, onSocket)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attach the listener to the message.
|
|
*
|
|
* @param {object} msg
|
|
* @return {function}
|
|
* @private
|
|
*/
|
|
|
|
function attachListener(msg, listener) {
|
|
var attached = msg.__onFinished
|
|
|
|
// create a private single listener with queue
|
|
if (!attached || !attached.queue) {
|
|
attached = msg.__onFinished = createListener(msg)
|
|
attachFinishedListener(msg, attached)
|
|
}
|
|
|
|
attached.queue.push(listener)
|
|
}
|
|
|
|
/**
|
|
* Create listener on message.
|
|
*
|
|
* @param {object} msg
|
|
* @return {function}
|
|
* @private
|
|
*/
|
|
|
|
function createListener(msg) {
|
|
function listener(err) {
|
|
if (msg.__onFinished === listener) msg.__onFinished = null
|
|
if (!listener.queue) return
|
|
|
|
var queue = listener.queue
|
|
listener.queue = null
|
|
|
|
for (var i = 0; i < queue.length; i++) {
|
|
queue[i](err, msg)
|
|
}
|
|
}
|
|
|
|
listener.queue = []
|
|
|
|
return listener
|
|
}
|
|
|
|
/**
|
|
* Patch ServerResponse.prototype.assignSocket for node.js 0.8.
|
|
*
|
|
* @param {ServerResponse} res
|
|
* @param {function} callback
|
|
* @private
|
|
*/
|
|
|
|
function patchAssignSocket(res, callback) {
|
|
var assignSocket = res.assignSocket
|
|
|
|
if (typeof assignSocket !== 'function') return
|
|
|
|
// res.on('socket', callback) is broken in 0.8
|
|
res.assignSocket = function _assignSocket(socket) {
|
|
assignSocket.call(this, socket)
|
|
callback(socket)
|
|
}
|
|
}
|