hexo/node_modules/ali-oss/shims/stream-http/lib/response.js

218 lines
6.2 KiB
JavaScript

var capability = require('./capability');
var inherits = require('inherits');
var stream = require('readable-stream');
var rStates = (exports.readyStates = {
UNSENT: 0,
OPENED: 1,
HEADERS_RECEIVED: 2,
LOADING: 3,
DONE: 4
});
var IncomingMessage = (exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {
var self = this;
stream.Readable.call(self);
self._mode = mode;
self.headers = {};
self.rawHeaders = [];
self.trailers = {};
self.rawTrailers = [];
// Fake the 'close' event, but only once 'end' fires
self.on('end', function () {
// The nextTick is necessary to prevent the 'request' module from causing an infinite loop
process.nextTick(function () {
self.emit('close');
});
});
if (mode === 'fetch') {
self._fetchResponse = response;
self.url = response.url;
self.statusCode = response.status;
self.statusMessage = response.statusText;
response.headers.forEach(function (header, key) {
self.headers[key.toLowerCase()] = header;
self.rawHeaders.push(key, header);
});
if (capability.writableStream) {
var writable = new WritableStream({
write: function (chunk) {
return new Promise(function (resolve, reject) {
if (self._destroyed) {
reject();
} else if (self.push(new Buffer(chunk))) {
resolve();
} else {
self._resumeFetch = resolve;
}
});
},
close: function () {
global.clearTimeout(fetchTimer);
if (!self._destroyed) self.push(null);
},
abort: function (err) {
if (!self._destroyed) self.emit('error', err);
}
});
try {
response.body.pipeTo(writable).catch(function (err) {
global.clearTimeout(fetchTimer);
if (!self._destroyed) self.emit('error', err);
});
return;
} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this
}
// fallback for when writableStream or pipeTo aren't available
var reader = response.body.getReader();
function read() {
reader
.read()
.then(function (result) {
if (self._destroyed) return;
if (result.done) {
global.clearTimeout(fetchTimer);
self.push(null);
return;
}
self.push(new Buffer(result.value));
read();
})
.catch(function (err) {
global.clearTimeout(fetchTimer);
if (!self._destroyed) self.emit('error', err);
});
}
read();
} else {
self._xhr = xhr;
self._pos = 0;
self.url = xhr.responseURL;
self.statusCode = xhr.status;
self.statusMessage = xhr.statusText;
var headers = xhr.getAllResponseHeaders().split(/\r?\n/);
headers.forEach(function (header) {
var matches = header.match(/^([^:]+):\s*(.*)/);
if (matches) {
var key = matches[1].toLowerCase();
if (key === 'set-cookie') {
if (self.headers[key] === undefined) {
self.headers[key] = [];
}
self.headers[key].push(matches[2]);
} else if (self.headers[key] !== undefined) {
self.headers[key] += ', ' + matches[2];
} else {
self.headers[key] = matches[2];
}
self.rawHeaders.push(matches[1], matches[2]);
}
});
self._charset = 'x-user-defined';
if (!capability.overrideMimeType) {
var mimeType = self.rawHeaders['mime-type'];
if (mimeType) {
var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/);
if (charsetMatch) {
self._charset = charsetMatch[1].toLowerCase();
}
}
if (!self._charset) self._charset = 'utf-8'; // best guess
}
}
});
inherits(IncomingMessage, stream.Readable);
IncomingMessage.prototype._read = function () {
var self = this;
var resolve = self._resumeFetch;
if (resolve) {
self._resumeFetch = null;
resolve();
}
};
IncomingMessage.prototype._onXHRProgress = function () {
var self = this;
var xhr = self._xhr;
var response = null;
switch (self._mode) {
case 'text:vbarray': // For IE9
if (xhr.readyState !== rStates.DONE) break;
try {
// This fails in IE8
response = new global.VBArray(xhr.responseBody).toArray();
} catch (e) {}
if (response !== null) {
self.push(new Buffer(response));
break;
}
// Falls through in IE8
case 'text':
try {
// This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4
response = xhr.responseText;
} catch (e) {
self._mode = 'text:vbarray';
break;
}
if (response.length > self._pos) {
var newData = response.substr(self._pos);
if (self._charset === 'x-user-defined') {
var buffer = new Buffer(newData.length);
for (var i = 0; i < newData.length; i++) buffer[i] = newData.charCodeAt(i) & 0xff;
self.push(buffer);
} else {
self.push(newData, self._charset);
}
self._pos = response.length;
}
break;
case 'arraybuffer':
if (xhr.readyState !== rStates.DONE || !xhr.response) break;
response = xhr.response;
self.push(new Buffer(new Uint8Array(response)));
break;
case 'moz-chunked-arraybuffer': // take whole
response = xhr.response;
if (xhr.readyState !== rStates.LOADING || !response) break;
self.push(new Buffer(new Uint8Array(response)));
break;
case 'ms-stream':
response = xhr.response;
if (xhr.readyState !== rStates.LOADING) break;
var reader = new global.MSStreamReader();
reader.onprogress = function () {
if (reader.result.byteLength > self._pos) {
self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))));
self._pos = reader.result.byteLength;
}
};
reader.onload = function () {
self.push(null);
};
// reader.onerror = ??? // TODO: this
reader.readAsArrayBuffer(response);
break;
}
// The ms-stream case handles end separately in reader.onload()
if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
self.push(null);
}
};