Source: lib/travis-status-http.js

  1. /**
  2.  * @copyright Copyright 2016 Kevin Locke <kevin@kevinlocke.name>
  3.  * @license MIT
  4.  */
  6. 'use strict';
  8. const TravisHttp = require('travis-ci/lib/travis-http');
  9. const caseless = require('caseless');
  10. const { inherits } = require('util');
  11. const request = require('request');
  12. const requestPackageJson = require('request/package.json');
  14. const constants = require('./constants');
  15. const packageJson = require('../package.json');
  16. const trimSlash = require('./trim-slash');
  18. /** Default <code>User-Agent</code> header to send with API requests.
  19.  * @const
  20.  * @private
  21.  */
  22. const DEFAULT_USER_AGENT = `node-travis-status/${packageJson.version
  23. } Request/${requestPackageJson.version
  24. } Node.js/${process.version}`;
  26. /** Creates an instance of the travis-ci HTTP agent with a given endpoint
  27.  * and request options.
  28.  *
  29.  * This class has the following features above <code>TravisHttp</code>:
  30.  * - Uses a newer version of request (for gzip and proxy support)
  31.  * - Supports caller-specified API endpoints (e.g. for enterprise or local use)
  32.  * - Supports caller-specified request options (e.g. pooling, strictSSL, proxy,
  33.  *   tunnel, timeouts, etc.)
  34.  * - Improved error values which are real Error instances and include the
  35.  *   HTTP response information, regardless of content.
  36.  *
  37.  * @param {string=} endpoint Travis CI API endpoint (base URL).
  38.  * (default: {@link TravisStatusChecker.ORG_URI})
  39.  * @param {Object=} options Options to pass to the <code>request</code>
  40.  * constructor.
  41.  */
  42. function TravisStatusHttp(endpoint, options) {
  43.   if (endpoint && typeof endpoint !== 'string') {
  44.     throw new TypeError('endpoint must be a string');
  45.   }
  46.   endpoint = endpoint && trimSlash(endpoint);
  48.   if (options && typeof options !== 'object') {
  49.     throw new TypeError('options must be an object');
  50.   }
  52.   options = { gzip: true, ...options };
  53.   options.headers = { ...options.headers };
  55.   // Careful about providing default values for case-insensitive headers
  56.   const caselessHeaders = caseless(options.headers);
  57.   // The Travis CI API docs say
  58.   // "Always set the Accept header to application/vnd.travis-ci.2+json"
  59.   // but the API actually sends Content-Type application/json.
  60.   // Declare that we accept either.
  61.   if (!caselessHeaders.has('Accept')) {
  62.     options.headers.Accept =
  63.       'application/vnd.travis-ci.2+json, application/json';
  64.   }
  65.   if (!caselessHeaders.has('User-Agent')) {
  66.     options.headers['User-Agent'] = DEFAULT_USER_AGENT;
  67.   }
  69.   TravisHttp.call(
  70.     this,
  71.     endpoint === constants.PRO_URI,
  72.     options.headers,
  73.   );
  75.   this._endpoint = endpoint || constants.ORG_URI;
  76.   // Set this._headers as TravisHttp does
  77.   this._headers = options.headers;
  78.   delete options.headers;
  79.   this._options = options;
  80. }
  81. inherits(TravisStatusHttp, TravisHttp);
  83. TravisStatusHttp.prototype._getHeaders = function _getHeaders() {
  84.   let headers = this._headers;
  86.   const token = this._getAccessToken();
  87.   if (token) {
  88.     let quotedToken;
  89.     // From https://tools.ietf.org/html/rfc7235#section-2.1
  90.     if (/^[A-Za-z0-9._~+/-]+$/.test(token)) {
  91.       // The token is a valid HTTP token68 and doesn't require quoting
  92.       quotedToken = token;
  93.     } else {
  94.       // Convert it to a quoted string
  95.       // Note:  No validation is done to ensure it doesn't have prohibited
  96.       // control characters, since there's no way to quote them and I'm more
  97.       // likely to screw up unicode handling than catch real errors.
  98.       quotedToken = `"${token.replace(/["\\]/g, '\\$&')}"`;
  99.     }
  101.     headers = { ...headers };
  102.     caseless(headers).del('Authorization');
  103.     headers.Authorization = `token ${quotedToken}`;
  104.   }
  106.   return headers;
  107. };
  109. TravisStatusHttp.prototype.request = function(method, path, data, callback) {
  110.   if (typeof data === 'function') {
  111.     callback = data;
  112.     data = undefined;
  113.   }
  115.   const options = {
  116.     ...this._options,
  117.     method,
  118.     url: this._endpoint + path,
  119.     headers: this._getHeaders(),
  120.   };
  122.   if (data instanceof Buffer) {
  123.     options.body = data;
  124.   } else {
  125.     options.json = data || true;
  126.   }
  127.   return request(options, (errRequest, res, body) => {
  128.     if (errRequest) {
  129.       callback(errRequest);
  130.       return;
  131.     }
  133.     let err;
  135.     if (res.statusCode >= 400) {
  136.       err = new Error(res.statusMessage);
  137.     }
  139.     if (typeof body === 'string') {
  140.       try {
  141.         body = JSON.parse(body);
  142.       } catch (errJson) {
  143.         err = err || errJson;
  144.       }
  145.     }
  147.     // Note:  This error handling deviates from travis-ci (which returns body
  148.     // or statusCode as err).  I think this is much more sane.
  149.     if (err) {
  150.       err.statusCode = res.statusCode;
  151.       err.statusMessage = res.statusMessage;
  152.       err.headers = res.headers;
  153.       err.body = body;
  154.       callback(err);
  155.       return;
  156.     }
  158.     callback(null, body);
  159.   });
  160. };
  162. module.exports = TravisStatusHttp;