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 copyIntoPlace(tmpPath, targetPath) {

  var deferred = kew.defer();

  // Look for the extracted directory, so we can rename it.

  var files = fs.readdirSync(tmpPath);

  for (var i = 0; i < files.length; i++) {

    var file = path.join(tmpPath, files[i]);

    if (fs.statSync(file).isFile() && file.search('zip') === -1) {

      console.log('Renaming extracted folder', file, '->', targetPath);

      if (process.platform === 'win32') {

        targetPath = targetPath + '.exe';

      }

      ncp(file, targetPath, deferred.makeNodeResolver());

      break;

    }

  }

  return deferred.promise;

}

function fixFilePermissions() {

  // Check that the binary is user-executable and fix it if it isn't (problems with unzip library)

  if (process.platform !== 'win32') {

    var stat = fs.statSync(helper.path);

    // 64 == 0100 (no octal literal in strict mode)

    if (!(stat.mode & 64)) {

      console.log('Fixing file permissions');

      fs.chmodSync(helper.path, '755');

    }

  }

}

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);

  });

});