runtime-image/contents/install_node

#!/usr/bin/env node

var semver = require('semver');
var https = require('https');
var spawn = require('child_process').spawn;

function request(method, host, path, cb) {
  var options = {
    'host': host,
    'method': method,
    'path': path
  };

  var req = https.request(options, function(res) {
    if (res.statusCode != 200) {
      return cb(new Error('Returned status code: ' + res.statusCode));
    }

    var body = '';

    res.on('data', function(d) {
      body += d;
    });

    res.on('end', function() {
      cb(null, body, res);
    });
  });

  req.end();
}


function getAvailableVersions(cb) {
  request(
    'GET', 'storage.googleapis.com', '/gcp-node-packages/node_versions',
    function(err, body) {
      if (err) {
        return cb(err);
      }
      return cb(
        null,
        body
          .trim()
          .split('\n')
          .sort(function(a, b) {
            if (semver.gt(a, b)) {
              return -1;
            }
            return +1;
          })
      );
    }
  );
}


function getSatisfyingVersion(requestedVersion, cb) {
  getAvailableVersions(function(err, versions) {
    if (err) {
      return cb(err);
    }
    var satisfied = versions.some(function(version) {
      if (semver.satisfies(version, requestedVersion)) {
        cb(null, version);
        return true;
      }
    });
    if (!satisfied) {
      return cb(new Error(
        'No Node.js version satisfying ' + requestedVersion + ' found.'));
    }
  });
}


function verifyBinaryExists(version, cb) {
  request(
    'HEAD',
    'storage.googleapis.com',
    '/gcp-node-packages/node-' + version + '-linux-x64.tar.gz',
    function(err) {
      if (err) {
        return cb(new Error(
          'Binary for Node.js version ' + version + ' is not available.'));
      }
      return cb();
    });
}


function downloadAndInstallVersion(version, args, cb) {
  var command = '/opt/gcp/runtime/bootstrap_node';
  var proc = spawn(command, [version].concat(args ? args : []));

  proc.stdout.pipe(process.stdout);
  proc.stderr.pipe(process.stderr);

  // wrap the callback to use state to ensure the callback
  // is not called more than once
  var invoked = false;
  function guardedCallback(err) {
    if (invoked) {
      return;
    }

    invoked = true;
    return cb(err);
  }

  proc.on('error', guardedCallback);
  proc.on('exit', function(code) {
    return guardedCallback(code === 0 ? null :
      new Error(command + ' exited with a non-zero exit code: ' + code));
  });
}


function fail(err) {
  console.error('Node installation failed: ' + err.message);
  process.exit(1);
}


function main(requestedVersion, args) {
  // Does the current Node.js version already satisfy the requested version?
  // If so, we have nothing to do.
  if (semver.satisfies(process.version, requestedVersion)) {
    return;
  }

  // Otherwise, find which version satisfies and install it.
  getSatisfyingVersion(requestedVersion, function(err, version) {
    if (err) {
      return fail(err);
    }
    verifyBinaryExists(version, function(err) {
      if (err) {
        return fail(err);
      }
      downloadAndInstallVersion(version, args, function(err) {
        if (err) {
          return fail(err);
        }
        console.log('Installed Node.js ' + version);
      });
    });
  });
}

function printUsageAndExit() {
  console.log('Usage: install_node: [--ignore-verification-failure] [--direct] [--help] version');
  console.log('');
  console.log('Verifies and installs the specified version of Node.js.');
  console.log('');
  console.log('Options:');
  console.log('  --ignore-verification-failure  If the binary verification fails,');
  console.log('                                 still continue with the installation.');
  console.log('                                 By default, if binary verification');
  console.log('                                 fails, the installation is aborted.');
  console.log('  --direct                       Download and install directly from');
  console.log('                                 nodejs.org instead of from');
  console.log('                                 https://storage.googleapis.com/gcp-node-packages');
  console.log('  --help                         Prints this help message');
  console.log('');
  console.log('  version                        The version of Node.js to install.');
  console.log('                                 The version number is expected to be');
  console.log('                                 of the form \'v#.#.#\'.');
  process.exit(1);
}

var spec;
var args = [];

for (var i=2; i<process.argv.length; i++) {
  var a = process.argv[i];
  // Check if the argument starts with '--' in a way that can be used with
  // Node >= 0.10.0
  if (a.indexOf('--') === 0) {
    args.push(a);
  }
  else {
    if (spec) {
      console.log('Exactly one version must be specified.');
      printUsageAndExit();
    }
    else {
      spec = a;
    }
  }
}

if (!spec) {
  printUsageAndExit();
}

main(spec, args);