pkg-fetch/lib-es5/upload.js

Github Releases page of this project contains base binaries, used by `pkg` to create executables. `pkg-fetch` npm package downloads base binaries or compiles them from source.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.main = undefined;

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var main = exports.main = function () {
  var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
    var nodeVersion, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, targetArch, local, short, remote;

    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (process.env.GITHUB_USERNAME) {
              _context.next = 2;
              break;
            }

            throw (0, _log.wasReported)('No github credentials. Upload will fail!');

          case 2:
            _context.t0 = _regenerator2.default.keys(_patches2.default);

          case 3:
            if ((_context.t1 = _context.t0()).done) {
              _context.next = 52;
              break;
            }

            nodeVersion = _context.t1.value;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _iteratorError = undefined;
            _context.prev = 8;
            _iterator = (0, _getIterator3.default)(_system.targetArchs);

          case 10:
            if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
              _context.next = 36;
              break;
            }

            targetArch = _step.value;

            if (!dontBuild(nodeVersion, _system.hostPlatform, targetArch)) {
              _context.next = 14;
              break;
            }

            return _context.abrupt('continue', 33);

          case 14:
            local = (0, _places.localPlace)({ from: 'built', arch: targetArch,
              nodeVersion: nodeVersion, platform: _system.hostPlatform, version: _package.version });
            short = _path2.default.basename(local);

            _log.log.info('Building ' + short + '...');
            _context.next = 19;
            return (0, _build2.default)(nodeVersion, targetArch, local);

          case 19:
            _log.log.info('Verifying ' + short + '...');
            _context.next = 22;
            return (0, _verify.verify)(local);

          case 22:
            _log.log.info('Uploading ' + short + '...');
            remote = (0, _places.remotePlace)({ arch: targetArch,
              nodeVersion: nodeVersion, platform: _system.hostPlatform, version: _package.version });
            _context.prev = 24;
            _context.next = 27;
            return cloud.upload(local, remote);

          case 27:
            _context.next = 33;
            break;

          case 29:
            _context.prev = 29;
            _context.t2 = _context['catch'](24);

            // TODO catch only network errors
            if (!_context.t2.wasReported) _log.log.error(_context.t2);
            _log.log.info('Meanwhile i will continue making binaries');

          case 33:
            _iteratorNormalCompletion = true;
            _context.next = 10;
            break;

          case 36:
            _context.next = 42;
            break;

          case 38:
            _context.prev = 38;
            _context.t3 = _context['catch'](8);
            _didIteratorError = true;
            _iteratorError = _context.t3;

          case 42:
            _context.prev = 42;
            _context.prev = 43;

            if (!_iteratorNormalCompletion && _iterator.return) {
              _iterator.return();
            }

          case 45:
            _context.prev = 45;

            if (!_didIteratorError) {
              _context.next = 48;
              break;
            }

            throw _iteratorError;

          case 48:
            return _context.finish(45);

          case 49:
            return _context.finish(42);

          case 50:
            _context.next = 3;
            break;

          case 52:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this, [[8, 38, 42, 50], [24, 29], [43,, 45, 49]]);
  }));

  return function main() {
    return _ref.apply(this, arguments);
  };
}();

exports.dontBuild = dontBuild;

var _system = require('./system.js');

var _places = require('./places.js');

var _log = require('./log.js');

var _cloud = require('./cloud.js');

var _build = require('./build.js');

var _build2 = _interopRequireDefault(_build);

var _patches = require('../patches/patches.json');

var _patches2 = _interopRequireDefault(_patches);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _verify = require('./verify.js');

var _package = require('../package.json');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var cloud = new _cloud.Cloud({ owner: 'zeit', repo: 'pkg-fetch' });

function dontBuild(nodeVersion, targetPlatform, targetArch) {
  // https://support.apple.com/en-us/HT201948
  // don't disable macos-x86 because it is not possible
  // to cross-compile for x86 from macos otherwise
  var major = nodeVersion.match(/^v?(\d+)/)[1] | 0;
  // node 0.12 does not compile on arm
  if (/^arm/.test(targetArch) && major === 0) return true;
  // obstacles on freebsd x86 for node4
  if (targetPlatform === 'freebsd' && targetArch === 'x86' && major < 6) return true;
  if (targetPlatform === 'freebsd' && major < 4) return true;
  if (targetPlatform === 'alpine' && (targetArch !== 'x64' || major < 6)) return true;
  return false;
}

if (!module.parent) {
  main().catch(function (error) {
    if (!error.wasReported) _log.log.error(error);
    process.exit(2);
  });
}