Plato - install.js

// Shamelessly copied from The Obvious Corporation

/*
 * This simply fetches the right version of chromedriver for the current platform.
 */

'use strict';

var cp = require('child_process');
var fs = require('fs');
var http = require('http');
var kew = require('kew');
var path = require('path');
var url = require('url');
var rimraf = require('rimraf').sync;
var AdmZip = require('adm-zip');
var helper = require('./lib/chromedriver');
var ncp = require('ncp');
var npmconf = require('npmconf');
var util = require('util');

var libPath = path.join(__dirname, 'lib', 'bin', 'chromedriver');
var downloadUrl = 'http://chromedriver.storage.googleapis.com/2.9/chromedriver_';

if (process.platform === 'linux' && process.arch === 'x64') {
  downloadUrl += 'linux64.zip';
} else if (process.platform === 'linux') {
  downloadUrl += 'linux32.zip';
} else if (process.platform === 'darwin') {
  downloadUrl += 'mac32.zip';
} else if (process.platform === 'win32') {
  downloadUrl += 'win32.zip';
} else {
  console.log('Unexpected platform or architecture:', process.platform, process.arch);
  process.exit(1);
}

var fileName = downloadUrl.split('/').pop();

function getRequestOptions(proxyUrl) {
  if (proxyUrl) {
    var options = url.parse(proxyUrl);
    options.path = downloadUrl;
    options.headers = { Host: url.parse(downloadUrl).host };
    // turn basic authorization into proxy-authorization
    if (options.auth) {
      options.headers['Proxy-Authorization'] = 'Basic ' + new Buffer(options.auth).toString('base64');
      delete options.auth;
    }

return options;
  } else {
    return url.parse(downloadUrl);
  }
}

function requestBinary(requestOptions, filePath) {
  var deferred = kew.defer();

var count = 0;
  var notifiedCount = 0;
  var outFile = fs.openSync(filePath, 'w');

var client = http.get(requestOptions, function (response) {
    var status = response.statusCode;
    console.log('Receiving...');

if (status === 200) {
      response.addListener('data',   function (data) {
        fs.writeSync(outFile, data, 0, data.length, null);
        count += data.length;
        if ((count - notifiedCount) > 800000) {
          console.log('Received ' + Math.floor(count / 1024) + 'K...');
          notifiedCount = count;
        }
      });

response.addListener('end',   function () {
        console.log('Received ' + Math.floor(count / 1024) + 'K total.');
        fs.closeSync(outFile);
        deferred.resolve(true);
      });

} else {
      client.abort();
      deferred.reject('Error with http request: ' + util.inspect(response.headers));
    }
  });

return deferred.promise;
}

function extractDownload(filePath, tmpPath) {
  var deferred = kew.defer();
  var options = {cwd: tmpPath};

rimraf(libPath);

if (filePath.substr(-4) === '.zip') {
    console.log('Extracting zip contents');
    try {
      var zip = new AdmZip(filePath);
      zip.extractAllTo(path.dirname(filePath), true);
      deferred.resolve(true);
    } catch (e) {
      console.log(e);
      deferred.reject('Error extracting archive ' + e.stack);
    }

} else {
    console.log('Extracting tar contents (via spawned process)');
    cp.execFile('tar', ['jxf', filePath], options, function (err) {
      if (err) {
        deferred.reject('Error extracting archive ' + err.stack);
      } else {
        deferred.resolve(true);
      }
    });
  }
  return deferred.promise;
}

function mkdir(name) {
  var dir = path.dirname(name);
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir);
  }
}

npmconf.load(function(err, conf) {
  if (err) {
    console.log('Error loading npm config');
    console.error(err);
    process.exit(1);
    return;
  }

var tmpPath = path.join(conf.get('tmp'), 'chromedriver');
  var downloadedFile = path.join(tmpPath, fileName);

var promise= kew.resolve(true);

// Start the install.
  if (!fs.existsSync(downloadedFile)) {
    promise = promise.then(function () {
      rimraf(tmpPath);
      mkdir(downloadedFile);
      console.log('Downlaoading', downloadUrl);
      console.log('Saving to', downloadedFile);
      return requestBinary(getRequestOptions(conf.get('proxy')), downloadedFile);
    });

} else {
    console.log('Download already available at', downloadedFile);
  }

promise.then(function () {
    return extractDownload(downloadedFile, tmpPath);
  })
  .then(function () {
    return copyIntoPlace(tmpPath, libPath);
  })
  .then(function () {
    return fixFilePermissions();
  })
  .then(function () {
    console.log('Done. Chromedriver binary available at', helper.path);
  })
  .fail(function (err) {
    console.error('Chromedriver installation failed', err.stack);
    process.exit(1);
  });
});

install.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC