@nocobase/plugin-file-manager 2.0.0-alpha.9 → 2.0.0-beta.2

package/dist/node_modules/ali-oss/shims/xhr.js

@@ -0,0 +1,798 @@
+'use strict';
+const util = require('util');
+const urlutil = require('url');
+const http = require('http');
+const https = require('https');
+const debug = require('debug')('urllib');
+const ms = require('humanize-ms');
+let REQUEST_ID = 0;
+const MAX_VALUE = Math.pow(2, 31) - 10;
+const PROTO_RE = /^https?:\/\//i;
+
+function getAgent(agent, defaultAgent) {
+  return agent === undefined ? defaultAgent : agent;
+}
+
+function parseContentType(str) {
+  if (!str) {
+    return '';
+  }
+
+  return str.split(';')[0].trim().toLowerCase();
+}
+
+function makeCallback(resolve, reject) {
+  return function (err, data, res) {
+    if (err) {
+      return reject(err);
+    }
+    resolve({
+      data: data,
+      status: res.statusCode,
+      headers: res.headers,
+      res: res
+    });
+  };
+}
+
+// exports.TIMEOUT = ms('5s');
+exports.TIMEOUTS = [ms('300s'), ms('300s')];
+
+const TEXT_DATA_TYPES = ['json', 'text'];
+
+exports.request = function request(url, args, callback) {
+  // request(url, callback)
+  if (arguments.length === 2 && typeof args === 'function') {
+    callback = args;
+    args = null;
+  }
+  if (typeof callback === 'function') {
+    return exports.requestWithCallback(url, args, callback);
+  }
+
+  return new Promise(function (resolve, reject) {
+    exports.requestWithCallback(url, args, makeCallback(resolve, reject));
+  });
+};
+
+exports.requestWithCallback = function requestWithCallback(url, args, callback) {
+  if (!url || (typeof url !== 'string' && typeof url !== 'object')) {
+    const msg = util.format('expect request url to be a string or a http request options, but got' + ' %j', url);
+    throw new Error(msg);
+  }
+
+  if (arguments.length === 2 && typeof args === 'function') {
+    callback = args;
+    args = null;
+  }
+
+  args = args || {};
+  if (REQUEST_ID >= MAX_VALUE) {
+    REQUEST_ID = 0;
+  }
+  const reqId = ++REQUEST_ID;
+
+  args.requestUrls = args.requestUrls || [];
+
+  const reqMeta = {
+    requestId: reqId,
+    url: url,
+    args: args,
+    ctx: args.ctx
+  };
+  if (args.emitter) {
+    args.emitter.emit('request', reqMeta);
+  }
+
+  args.timeout = args.timeout || exports.TIMEOUTS;
+  args.maxRedirects = args.maxRedirects || 10;
+  args.streaming = args.streaming || args.customResponse;
+  const requestStartTime = Date.now();
+  let parsedUrl;
+
+  if (typeof url === 'string') {
+    if (!PROTO_RE.test(url)) {
+      // Support `request('www.server.com')`
+      url = 'https://' + url;
+    }
+    parsedUrl = urlutil.parse(url);
+  } else {
+    parsedUrl = url;
+  }
+
+  const method = (args.type || args.method || parsedUrl.method || 'GET').toUpperCase();
+  let port = parsedUrl.port || 80;
+  let httplib = http;
+  let agent = getAgent(args.agent, exports.agent);
+  const fixJSONCtlChars = args.fixJSONCtlChars;
+
+  if (parsedUrl.protocol === 'https:') {
+    httplib = https;
+    agent = getAgent(args.httpsAgent, exports.httpsAgent);
+
+    if (!parsedUrl.port) {
+      port = 443;
+    }
+  }
+
+  // request through proxy tunnel
+  // var proxyTunnelAgent = detectProxyAgent(parsedUrl, args);
+  // if (proxyTunnelAgent) {
+  //   agent = proxyTunnelAgent;
+  // }
+
+  const options = {
+    host: parsedUrl.hostname || parsedUrl.host || 'localhost',
+    path: parsedUrl.path || '/',
+    method: method,
+    port: port,
+    agent: agent,
+    headers: args.headers || {},
+    // default is dns.lookup
+    // https://github.com/nodejs/node/blob/master/lib/net.js#L986
+    // custom dnslookup require node >= 4.0.0
+    // https://github.com/nodejs/node/blob/archived-io.js-v0.12/lib/net.js#L952
+    lookup: args.lookup
+  };
+
+  if (Array.isArray(args.timeout)) {
+    options.requestTimeout = args.timeout[args.timeout.length - 1];
+  } else if (typeof args.timeout !== 'undefined') {
+    options.requestTimeout = args.timeout;
+  }
+
+  // const sslNames = [
+  //   'pfx',
+  //   'key',
+  //   'passphrase',
+  //   'cert',
+  //   'ca',
+  //   'ciphers',
+  //   'rejectUnauthorized',
+  //   'secureProtocol',
+  //   'secureOptions',
+  // ];
+  // for (let i = 0; i < sslNames.length; i++) {
+  //   const name = sslNames[i];
+  //   if (args.hasOwnProperty(name)) {
+  //     options[name] = args[name];
+  //   }
+  // }
+
+  // don't check ssl
+  // if (options.rejectUnauthorized === false && !options.hasOwnProperty('secureOptions')) {
+  //   options.secureOptions = require('constants').SSL_OP_NO_TLSv1_2;
+  // }
+
+  const auth = args.auth || parsedUrl.auth;
+  if (auth) {
+    options.auth = auth;
+  }
+
+  // content undefined  data 有值
+  let body = args.content || args.data;
+  const dataAsQueryString = method === 'GET' || method === 'HEAD' || args.dataAsQueryString;
+  if (!args.content) {
+    if (body && !(typeof body === 'string' || Buffer.isBuffer(body))) {
+      if (dataAsQueryString) {
+        // read: GET, HEAD, use query string
+        body = args.nestedQuerystring ? qs.stringify(body) : querystring.stringify(body);
+      } else {
+        let contentType = options.headers['Content-Type'] || options.headers['content-type'];
+        // auto add application/x-www-form-urlencoded when using urlencode form request
+        if (!contentType) {
+          if (args.contentType === 'json') {
+            contentType = 'application/json';
+          } else {
+            contentType = 'application/x-www-form-urlencoded';
+          }
+          options.headers['Content-Type'] = contentType;
+        }
+
+        if (parseContentType(contentType) === 'application/json') {
+          body = JSON.stringify(body);
+        } else {
+          // 'application/x-www-form-urlencoded'
+          body = args.nestedQuerystring ? qs.stringify(body) : querystring.stringify(body);
+        }
+      }
+    }
+  }
+
+  // if it's a GET or HEAD request, data should be sent as query string
+  if (dataAsQueryString && body) {
+    options.path += (parsedUrl.query ? '&' : '?') + body;
+    body = null;
+  }
+
+  let requestSize = 0;
+  if (body) {
+    let length = body.length;
+    if (!Buffer.isBuffer(body)) {
+      length = Buffer.byteLength(body);
+    }
+    requestSize = options.headers['Content-Length'] = length;
+  }
+
+  if (args.dataType === 'json') {
+    options.headers.Accept = 'application/json';
+  }
+
+  if (typeof args.beforeRequest === 'function') {
+    // you can use this hook to change every thing.
+    args.beforeRequest(options);
+  }
+  let connectTimer = null;
+  let responseTimer = null;
+  let __err = null;
+  let connected = false; // socket connected or not
+  let keepAliveSocket = false; // request with keepalive socket
+  let responseSize = 0;
+  let statusCode = -1;
+  let responseAborted = false;
+  let remoteAddress = '';
+  let remotePort = '';
+  let timing = null;
+  if (args.timing) {
+    timing = {
+      // socket assigned
+      queuing: 0,
+      // dns lookup time
+      dnslookup: 0,
+      // socket connected
+      connected: 0,
+      // request sent
+      requestSent: 0,
+      // Time to first byte (TTFB)
+      waiting: 0,
+      contentDownload: 0
+    };
+  }
+
+  function cancelConnectTimer() {
+    if (connectTimer) {
+      clearTimeout(connectTimer);
+      connectTimer = null;
+    }
+  }
+  function cancelResponseTimer() {
+    if (responseTimer) {
+      clearTimeout(responseTimer);
+      responseTimer = null;
+    }
+  }
+
+  function done(err, data, res) {
+    cancelResponseTimer();
+    if (!callback) {
+      console.warn(
+        '[urllib:warn] [%s] [%s] [worker:%s] %s %s callback twice!!!',
+        Date(),
+        reqId,
+        process.pid,
+        options.method,
+        url
+      );
+      // https://github.com/node-modules/urllib/pull/30
+      if (err) {
+        console.warn(
+          '[urllib:warn] [%s] [%s] [worker:%s] %s: %s\nstack: %s',
+          Date(),
+          reqId,
+          process.pid,
+          err.name,
+          err.message,
+          err.stack
+        );
+      }
+      return;
+    }
+    const cb = callback;
+    callback = null;
+    let headers = {};
+    if (res) {
+      statusCode = res.statusCode;
+      headers = res.headers;
+    }
+
+    // handle digest auth
+    // if (statusCode === 401 && headers['www-authenticate']
+    //   && (!args.headers || !args.headers.Authorization) && args.digestAuth) {
+    //   const authenticate = headers['www-authenticate'];
+    //   if (authenticate.indexOf('Digest ') >= 0) {
+    //     debug('Request#%d %s: got digest auth header WWW-Authenticate: %s', reqId, url, authenticate);
+    //     args.headers = args.headers || {};
+    //     args.headers.Authorization = digestAuthHeader(options.method, options.path, authenticate, args.digestAuth);
+    //     debug('Request#%d %s: auth with digest header: %s', reqId, url, args.headers.Authorization);
+    //     if (res.headers['set-cookie']) {
+    //       args.headers.Cookie = res.headers['set-cookie'].join(';');
+    //     }
+    //     return exports.requestWithCallback(url, args, cb);
+    //   }
+    // }
+
+    const requestUseTime = Date.now() - requestStartTime;
+    if (timing) {
+      timing.contentDownload = requestUseTime;
+    }
+
+    debug(
+      '[%sms] done, %s bytes HTTP %s %s %s %s, keepAliveSocket: %s, timing: %j',
+      requestUseTime,
+      responseSize,
+      statusCode,
+      options.method,
+      options.host,
+      options.path,
+      keepAliveSocket,
+      timing
+    );
+
+    const response = {
+      status: statusCode,
+      statusCode: statusCode,
+      headers: headers,
+      size: responseSize,
+      aborted: responseAborted,
+      rt: requestUseTime,
+      keepAliveSocket: keepAliveSocket,
+      data: data,
+      requestUrls: args.requestUrls,
+      timing: timing,
+      remoteAddress: remoteAddress,
+      remotePort: remotePort
+    };
+
+    if (err) {
+      let agentStatus = '';
+      if (agent && typeof agent.getCurrentStatus === 'function') {
+        // add current agent status to error message for logging and debug
+        agentStatus = ', agent status: ' + JSON.stringify(agent.getCurrentStatus());
+      }
+      err.message +=
+        ', ' +
+        options.method +
+        ' ' +
+        url +
+        ' ' +
+        statusCode +
+        ' (connected: ' +
+        connected +
+        ', keepalive socket: ' +
+        keepAliveSocket +
+        agentStatus +
+        ')' +
+        '\nheaders: ' +
+        JSON.stringify(headers);
+      err.data = data;
+      err.path = options.path;
+      err.status = statusCode;
+      err.headers = headers;
+      err.res = response;
+    }
+
+    cb(err, data, args.streaming ? res : response);
+
+    if (args.emitter) {
+      // keep to use the same reqMeta object on request event before
+      reqMeta.url = url;
+      reqMeta.socket = req && req.connection;
+      reqMeta.options = options;
+      reqMeta.size = requestSize;
+
+      args.emitter.emit('response', {
+        requestId: reqId,
+        error: err,
+        ctx: args.ctx,
+        req: reqMeta,
+        res: response
+      });
+    }
+  }
+
+  function handleRedirect(res) {
+    let err = null;
+    if (args.followRedirect && statuses.redirect[res.statusCode]) {
+      // handle redirect
+      args._followRedirectCount = (args._followRedirectCount || 0) + 1;
+      const location = res.headers.location;
+      if (!location) {
+        err = new Error('Got statusCode ' + res.statusCode + ' but cannot resolve next location from headers');
+        err.name = 'FollowRedirectError';
+      } else if (args._followRedirectCount > args.maxRedirects) {
+        err = new Error('Exceeded maxRedirects. Probably stuck in a redirect loop ' + url);
+        err.name = 'MaxRedirectError';
+      } else {
+        const newUrl = args.formatRedirectUrl ? args.formatRedirectUrl(url, location) : urlutil.resolve(url, location);
+        debug('Request#%d %s: `redirected` from %s to %s', reqId, options.path, url, newUrl);
+        // make sure timer stop
+        cancelResponseTimer();
+        // should clean up headers.Host on `location: http://other-domain/url`
+        if (args.headers && args.headers.Host && PROTO_RE.test(location)) {
+          args.headers.Host = null;
+        }
+        // avoid done will be execute in the future change.
+        const cb = callback;
+        callback = null;
+        exports.requestWithCallback(newUrl, args, cb);
+        return {
+          redirect: true,
+          error: null
+        };
+      }
+    }
+    return {
+      redirect: false,
+      error: err
+    };
+  }
+
+  if (args.gzip) {
+    if (!options.headers['Accept-Encoding'] && !options.headers['accept-encoding']) {
+      options.headers['Accept-Encoding'] = 'gzip';
+    }
+  }
+
+  function decodeContent(res, body, cb) {
+    const encoding = res.headers['content-encoding'];
+    // if (body.length === 0) {
+    //   return cb(null, body, encoding);
+    // }
+
+    // if (!encoding || encoding.toLowerCase() !== 'gzip') {
+    return cb(null, body, encoding);
+    // }
+
+    // debug('gunzip %d length body', body.length);
+    // zlib.gunzip(body, cb);
+  }
+
+  const writeStream = args.writeStream;
+
+  debug('Request#%d %s %s with headers %j, options.path: %s', reqId, method, url, options.headers, options.path);
+
+  args.requestUrls.push(url);
+
+  function onResponse(res) {
+    if (timing) {
+      timing.waiting = Date.now() - requestStartTime;
+    }
+    debug('Request#%d %s `req response` event emit: status %d, headers: %j', reqId, url, res.statusCode, res.headers);
+
+    if (args.streaming) {
+      const result = handleRedirect(res);
+      if (result.redirect) {
+        res.resume();
+        return;
+      }
+      if (result.error) {
+        res.resume();
+        return done(result.error, null, res);
+      }
+
+      return done(null, null, res);
+    }
+
+    res.on('close', function () {
+      debug('Request#%d %s: `res close` event emit, total size %d', reqId, url, responseSize);
+    });
+
+    res.on('error', function () {
+      debug('Request#%d %s: `res error` event emit, total size %d', reqId, url, responseSize);
+    });
+
+    res.on('aborted', function () {
+      responseAborted = true;
+      debug('Request#%d %s: `res aborted` event emit, total size %d', reqId, url, responseSize);
+    });
+
+    if (writeStream) {
+      // If there's a writable stream to recieve the response data, just pipe the
+      // response stream to that writable stream and call the callback when it has
+      // finished writing.
+      //
+      // NOTE that when the response stream `res` emits an 'end' event it just
+      // means that it has finished piping data to another stream. In the
+      // meanwhile that writable stream may still writing data to the disk until
+      // it emits a 'close' event.
+      //
+      // That means that we should not apply callback until the 'close' of the
+      // writable stream is emited.
+      //
+      // See also:
+      // - https://github.com/TBEDP/urllib/commit/959ac3365821e0e028c231a5e8efca6af410eabb
+      // - http://nodejs.org/api/stream.html#stream_event_end
+      // - http://nodejs.org/api/stream.html#stream_event_close_1
+      const result = handleRedirect(res);
+      if (result.redirect) {
+        res.resume();
+        return;
+      }
+      if (result.error) {
+        res.resume();
+        // end ths stream first
+        writeStream.end();
+        return done(result.error, null, res);
+      }
+      // you can set consumeWriteStream false that only wait response end
+      if (args.consumeWriteStream === false) {
+        res.on('end', done.bind(null, null, null, res));
+      } else {
+        // node 0.10, 0.12: only emit res aborted, writeStream close not fired
+        // if (isNode010 || isNode012) {
+        //   first([
+        //     [ writeStream, 'close' ],
+        //     [ res, 'aborted' ],
+        //   ], function(_, stream, event) {
+        //     debug('Request#%d %s: writeStream or res %s event emitted', reqId, url, event);
+        //     done(__err || null, null, res);
+        //   });
+        if (false) {
+        } else {
+          writeStream.on('close', function () {
+            debug('Request#%d %s: writeStream close event emitted', reqId, url);
+            done(__err || null, null, res);
+          });
+        }
+      }
+      return res.pipe(writeStream);
+    }
+
+    // Otherwise, just concat those buffers.
+    //
+    // NOTE that the `chunk` is not a String but a Buffer. It means that if
+    // you simply concat two chunk with `+` you're actually converting both
+    // Buffers into Strings before concating them. It'll cause problems when
+    // dealing with multi-byte characters.
+    //
+    // The solution is to store each chunk in an array and concat them with
+    // 'buffer-concat' when all chunks is recieved.
+    //
+    // See also:
+    // http://cnodejs.org/topic/4faf65852e8fb5bc65113403
+
+    const chunks = [];
+
+    res.on('data', function (chunk) {
+      debug('Request#%d %s: `res data` event emit, size %d', reqId, url, chunk.length);
+      responseSize += chunk.length;
+      chunks.push(chunk);
+    });
+
+    res.on('end', function () {
+      const body = Buffer.concat(chunks, responseSize);
+      debug('Request#%d %s: `res end` event emit, total size %d, _dumped: %s', reqId, url, responseSize, res._dumped);
+
+      if (__err) {
+        // req.abort() after `res data` event emit.
+        return done(__err, body, res);
+      }
+
+      const result = handleRedirect(res);
+      if (result.error) {
+        return done(result.error, body, res);
+      }
+      if (result.redirect) {
+        return;
+      }
+
+      decodeContent(res, body, function (err, data, encoding) {
+        if (err) {
+          return done(err, body, res);
+        }
+        // if body not decode, dont touch it
+        if (!encoding && TEXT_DATA_TYPES.indexOf(args.dataType) >= 0) {
+          // try to decode charset
+          try {
+            data = decodeBodyByCharset(data, res);
+          } catch (e) {
+            debug('decodeBodyByCharset error: %s', e);
+            // if error, dont touch it
+            return done(null, data, res);
+          }
+
+          if (args.dataType === 'json') {
+            if (responseSize === 0) {
+              data = null;
+            } else {
+              const r = parseJSON(data, fixJSONCtlChars);
+              if (r.error) {
+                err = r.error;
+              } else {
+                data = r.data;
+              }
+            }
+          }
+        }
+
+        if (responseAborted) {
+          // err = new Error('Remote socket was terminated before `response.end()` was called');
+          // err.name = 'RemoteSocketClosedError';
+          debug('Request#%d %s: Remote socket was terminated before `response.end()` was called', reqId, url);
+        }
+
+        done(err, data, res);
+      });
+    });
+  }
+
+  let connectTimeout, responseTimeout;
+  if (Array.isArray(args.timeout)) {
+    connectTimeout = ms(args.timeout[0]);
+    responseTimeout = ms(args.timeout[1]);
+  } else {
+    // set both timeout equal
+    connectTimeout = responseTimeout = ms(args.timeout);
+  }
+  debug('ConnectTimeout: %d, ResponseTimeout: %d', connectTimeout, responseTimeout);
+
+  function startConnectTimer() {
+    debug('Connect timer ticking, timeout: %d', connectTimeout);
+    connectTimer = setTimeout(function () {
+      connectTimer = null;
+      if (statusCode === -1) {
+        statusCode = -2;
+      }
+      let msg = 'Connect timeout for ' + connectTimeout + 'ms';
+      let errorName = 'ConnectionTimeoutError';
+      if (!req.socket) {
+        errorName = 'SocketAssignTimeoutError';
+        msg += ', working sockets is full';
+      }
+      __err = new Error(msg);
+      __err.name = errorName;
+      __err.requestId = reqId;
+      debug('ConnectTimeout: Request#%d %s %s: %s, connected: %s', reqId, url, __err.name, msg, connected);
+      abortRequest();
+    }, connectTimeout);
+  }
+
+  function startResposneTimer() {
+    debug('Response timer ticking, timeout: %d', responseTimeout);
+    responseTimer = setTimeout(function () {
+      responseTimer = null;
+      const msg = 'Response timeout for ' + responseTimeout + 'ms';
+      const errorName = 'ResponseTimeoutError';
+      __err = new Error(msg);
+      __err.name = errorName;
+      __err.requestId = reqId;
+      debug('ResponseTimeout: Request#%d %s %s: %s, connected: %s', reqId, url, __err.name, msg, connected);
+      abortRequest();
+    }, responseTimeout);
+  }
+
+  let req;
+  // request headers checker will throw error
+  options.mode = args.mode ? args.mode : '';
+  try {
+    req = httplib.request(options, onResponse);
+  } catch (err) {
+    return done(err);
+  }
+
+  // environment detection: browser or nodejs
+  if (typeof window === 'undefined') {
+    // start connect timer just after `request` return, and just in nodejs environment
+    startConnectTimer();
+  } else {
+    req.on('requestTimeout', function () {
+      if (statusCode === -1) {
+        statusCode = -2;
+      }
+      const msg = 'Connect timeout for ' + connectTimeout + 'ms';
+      const errorName = 'ConnectionTimeoutError';
+      __err = new Error(msg);
+      __err.name = errorName;
+      __err.requestId = reqId;
+      abortRequest();
+    });
+  }
+
+  function abortRequest() {
+    debug('Request#%d %s abort, connected: %s', reqId, url, connected);
+    // it wont case error event when req haven't been assigned a socket yet.
+    if (!req.socket) {
+      __err.noSocket = true;
+      done(__err);
+    }
+    req.abort();
+  }
+
+  if (timing) {
+    // request sent
+    req.on('finish', function () {
+      timing.requestSent = Date.now() - requestStartTime;
+    });
+  }
+
+  req.once('socket', function (socket) {
+    if (timing) {
+      // socket queuing time
+      timing.queuing = Date.now() - requestStartTime;
+    }
+
+    // https://github.com/nodejs/node/blob/master/lib/net.js#L377
+    // https://github.com/nodejs/node/blob/v0.10.40-release/lib/net.js#L352
+    // should use socket.socket on 0.10.x
+    // if (isNode010 && socket.socket) {
+    //   socket = socket.socket;
+    // }
+
+    const readyState = socket.readyState;
+    if (readyState === 'opening') {
+      socket.once('lookup', function (err, ip, addressType) {
+        debug('Request#%d %s lookup: %s, %s, %s', reqId, url, err, ip, addressType);
+        if (timing) {
+          timing.dnslookup = Date.now() - requestStartTime;
+        }
+        if (ip) {
+          remoteAddress = ip;
+        }
+      });
+      socket.once('connect', function () {
+        if (timing) {
+          // socket connected
+          timing.connected = Date.now() - requestStartTime;
+        }
+
+        // cancel socket timer at first and start tick for TTFB
+        cancelConnectTimer();
+        startResposneTimer();
+
+        debug('Request#%d %s new socket connected', reqId, url);
+        connected = true;
+        if (!remoteAddress) {
+          remoteAddress = socket.remoteAddress;
+        }
+        remotePort = socket.remotePort;
+      });
+      return;
+    }
+
+    debug('Request#%d %s reuse socket connected, readyState: %s', reqId, url, readyState);
+    connected = true;
+    keepAliveSocket = true;
+    if (!remoteAddress) {
+      remoteAddress = socket.remoteAddress;
+    }
+    remotePort = socket.remotePort;
+
+    // reuse socket, timer should be canceled.
+    cancelConnectTimer();
+    startResposneTimer();
+  });
+
+  req.on('error', function (err) {
+    //TypeError for browser fetch api, Error for browser xmlhttprequest api
+    if (err.name === 'Error' || err.name === 'TypeError') {
+      err.name = connected ? 'ResponseError' : 'RequestError';
+    }
+    err.message += ' (req "error")';
+    debug('Request#%d %s `req error` event emit, %s: %s', reqId, url, err.name, err.message);
+    done(__err || err);
+  });
+
+  if (writeStream) {
+    writeStream.once('error', function (err) {
+      err.message += ' (writeStream "error")';
+      __err = err;
+      debug('Request#%d %s `writeStream error` event emit, %s: %s', reqId, url, err.name, err.message);
+      abortRequest();
+    });
+  }
+
+  if (args.stream) {
+    args.stream.pipe(req);
+    args.stream.once('error', function (err) {
+      err.message += ' (stream "error")';
+      __err = err;
+      debug('Request#%d %s `readStream error` event emit, %s: %s', reqId, url, err.name, err.message);
+      abortRequest();
+    });
+  } else {
+    req.end(body);
+  }
+
+  req.requestId = reqId;
+  return req;
+};