index.js

// ## tsm
// Titanium SDK manager
//
// This file contains functions for retreiving builds & build metadata from
// Appcelerator.  Tests are in `test.js`.

var request = require("request");
var async = require("async");
var semver = require("semver");
var fs = require("fs");
var path = require("path");
var util = require("util");
var EventEmitter = require("events").EventEmitter;
var exec = require('child_process').exec;
var spawn = require('child_process').spawn;
var rimraf = require('rimraf');

var tsm = {};
module.exports = tsm;

// ## Public API

// ### install
// * `options` object
//   * `dir` output directory
//   * `input` git hash or version to match
//   * `os` os to match, should be 'osx' 'win32' 'linux'
// * `done` callback, called with `(error)`
//
// Installs a matching SDK to the provided directory. Returns an emitter which
// will emit `progress` events like `{left: 38413, done: 5893, percent: 0.34}`,
// `debug` events and `log` events.
tsm.install = function (options, done) {
  var emitter = options.emitter || new EventEmitter();

  tsm.getAllBuilds(options.input, options.os, function (error, builds) {
    if (error) return done(error);
    if (builds.length === 0) return done(new Error("no matching SDK versions"));
    var build = builds.pop();
    var total = build.size;
    var left = total;
    var dest = path.join(options.dir, build.filename);

    emitter.emit('chose', build);

    var req = request(build.zip);
    req.pipe(fs.createWriteStream(dest));

    req.on('error', done);

    req.on('data', function (buffer) { 
      left -= buffer.length;
      emitter.emit('progress', {
        left: left, 
        done: total - left, 
        percent: (total-left) / total
      });
    });

    req.on('end', function () {
      var dir = path.resolve(options.dir, "..", "..");
      emitter.emit('debug', "complete");
      emitter.emit('downloaded', {dest: dest, dir: dir});
      tsm.unzip(dest, dir, function (er) {
        if (er) return done(er);

        emitter.emit('extracted', {dest: dest});
        fs.unlink(options.dir + "/" + build.filename, function (er) {
          if (er) return done(er);

          done(null);
          emitter.emit('done');
        });
      });
    });
  }, emitter);

  return emitter;
};

// ### remove
// * `options` object
//   * `dir` directory to find sdks
//   * `input` git hash or version to match
// * `done` callback called with `(error)`
//
// Removes sdks matching `input`. Returns an emitter which may emit `debug`
// and/or `log` events.

tsm.remove = function (options, done) {
  var emitter = options.emitter || new EventEmitter();

  tsm.findInstalled(options.dir, options.input, function (error, builds) {
    if (error) return done(error);
    if (builds.length === 0) return done(new Error('no matched builds'));
    var dirs = builds.map(function (item) { return item.dir; });
    async.forEach(dirs, function (item, callback) {
      emitter.emit('deleting', item);
      rimraf(item, callback);
    }, done);
  }, emitter);

  return emitter;
};

// ### list
// * `options` object, can have the following properties:
//   * `os` string *required* os of builds, one of 'osx' 'linux' 'win32'
//   * `installed` boolean, whether or not to include installed builds
//   * `available` boolean, whether or not to include uninstalled builds
//   * `dir` string, directory to look for installed builds
//   * `input` string, git hash or version to match
// * `done` callback called on completion with `(error, builds)`
//
// The complete solution for listing builds. Returns an EventEmitter which will
// emit 'log' and 'debug' events.

tsm.list = function (options, done) {
  if (typeof options.os !== 'string') 
    throw new TypeError("options.os is required");
  if (options.installed && typeof options.dir != 'string')
    throw new TypeError("options.dir is required for options.installed");

  var emitter = options.emitter || new EventEmitter();

  async.parallel({
    installed: function (callback) {
      if (!options.installed) callback(null, []);
      else {
        emitter.emit('debug', "Finding installed SDKs.");
        tsm.findInstalled(options.dir, options.input, callback, emitter);
      }
    },

    available: function (callback) {
      if (!options.available) callback(null, []);
      else {
        emitter.emit('debug', "Pulling available SDKs.");
        emitter.emit('available', options);
        tsm.getAllBuilds(options.input, options.os, callback, emitter);
      }
    }
  }, function (error, data) {
    if (error) done(error);
    else done(null, tsm.mergeBuilds(data.available, data.installed));
  });

  return emitter;
};

// ### builder
// * `options` object
//   * `dir` directory to find sdks
//   * `input` git hash or version to match
//   * `os` 'android' or 'iphone'
//   * `args` array of arguments to pass to builder.py
//   * `python` string, optional, path of python
//   * `silent` boolean; if true, output will be supressed
// * `done` callback to call when completed or upon error
//
// Runs the builder.py script for the specified `os`.

tsm.builder = function (options, done) {
  var emitter = options.emitter || new EventEmitter();
  options.python = options.python || 'python';

  tsm.findInstalled(options.dir, options.input, function (error, builds) {
    if (error) return done(error);
    if (builds.length === 0) return done (new Error('no matched builds'));
    var build = builds.pop();

    var args = [path.join(build.dir, options.os, 'builder.py')];
    var child = spawn('python', args.concat(options.args || []));
    emitter.emit('spawned', child);

    child.on('exit', function (code) {
      if (code === 0 || code === 255)
        done();
      else {
        var er = new Error("process exited with code: " + code);
        er.code = code;
        done(er);
      }
    });

    if (!options.silent) {
      child.stdout.pipe(process.stdout);
      child.stderr.pipe(process.stderr);
    }
  }, emitter);

  return emitter;
};

// ### titanium
// * `options` object
//   * `dir` directory to find sdks
//   * `input` git hash or version to match
//   * `args` array of arguments to pass to titanium.py
//   * `python` string, optional, path of python
//   * `silent` boolean; if true, output will be supressed
// * `done` callback to call when completed or upon error
//
// Runs the titanium.py script 

tsm.titanium = function (options, done) {
  var emitter = options.emitter || new EventEmitter();
  options.python = options.python || 'python';

  tsm.findInstalled(options.dir, options.input, function (error, builds) {
    if (error) return done(error);
    if (builds.length === 0) return done (new Error('no matched builds'));
    var build = builds.pop();

    var args = [path.join(build.dir, 'titanium.py')];
    args = args.concat(options.args || []);
    emitter.emit('debug', "spawning: python " + args);
    var child = spawn('python', args);
    emitter.emit('spawned', child);

    child.on('exit', function (code) {
      if (code === 0 || code === 255)
        done();
      else {
        var er = new Error("process exited with code: " + code);
        er.code = code;
        done(er);
      }
    });

    if (!options.silent) {
      child.stdout.pipe(process.stdout);
      child.stderr.pipe(process.stderr);
    }
  }, emitter);

  return emitter;
};

// ## Helper functions

var branchesURL = 
  'http://builds.appcelerator.com.s3.amazonaws.com/mobile/branches.json';
var branchURL = 
  'http://builds.appcelerator.com.s3.amazonaws.com/mobile/$BRANCH/index.json';

// zipURL needs branch/zipname added to it
var zipURL = 'http://builds.appcelerator.com.s3.amazonaws.com/mobile/';

// ### gitCheck
// * `input` some partial hash
// * `revision` some git revision hash
//
// Checks to see if the given input matches the given hash
tsm.gitCheck = function (input, revision) {
  if (input && input.length > 1 && revision.indexOf(input) === 0) return true;
  else return false;
};

// ### getBranches
// * `done` callback to be called when complete, passed `(error, data)`
//
// Gets a list of branches from Appcelerator, formatted as an array of strings
tsm.getBranches = function (done) {
  request(branchesURL, function (error, response, body) {
    try {
      if (error) throw error;
      if (response.statusCode != 200) 
        throw new Error("HTTP " + response.statusCode);

      var data = JSON.parse(body).branches;
      if (!data) throw new Error("got malformed response from appcelerator");

      done(null, data);
    } catch (e) { done(e); }
  });
};

// ### parseDate
// * `dateStr` string to parse date out of
//
// Parses dates from the strange way Appcelerator chooses to format them.
// Returns a date object.

tsm.parseDate = function (dateStr) {
  var date = new Date();

  // date parsing code stolen right off of builds.appcelerator.net
  date.setFullYear(
    dateStr.substring(0,4), dateStr.substring(4,6)-1, dateStr.substring(6,8));
  date.setHours(dateStr.substring(8, 10));
  date.setMinutes(dateStr.substring(10,12));
  date.setSeconds(dateStr.substring(12,14));

  return date;
};

// ### parseBuildList
// * `input` version or git hash to match against builds, can be falsy
// * `os` should be 'linux' or 'osx' or 'win32'
// * `builds` array of builds to parse
//
// Parses a build list from appcelerator, matching only those builds we're
// interested in. Returns a list of builds formatted like:

//     [
//       {
//         date: date object corresponding to build date,
//         version: version string like '2.2.0',
//         zip: zip url,
//         git_revision: git hash,
//         githash: short git hash (first 7 chars),
//         sha1: sha1 hash of file,
//         size: size in bytes,
//         git_branch: git branch name,
//         build_type: mobile or desktop,
//         filename: basename ie 'mobilesdk-2.2.0-version.zip',
//         build_url: jenkins url
//       },
//       ...
//     ]

tsm.parseBuildList = function (input, os, builds, emitter) {
  return builds.filter(function (item) { 
    if (os && item.filename.indexOf(os) === -1) return false;

    var match;

    // Parse out version from filename (without date on the end)
    match = item.filename.match(/[0-9]*\.[0-9]*\.[0-9]*/);
    if (Array.isArray(match)) item.version = match[0];

    // Parse out date from filename 
    match = item.filename.match(/[0-9]{14}/);
    if (Array.isArray(match)) item.date = tsm.parseDate(match[0]);

    item.zip = zipURL + item.git_branch + "/" + item.filename;
    item.githash = item.git_revision.slice(0, 7);

    // Ignore invalid builds. Shouldn't fail unless they change something..
    if (!item.version || !item.date) {
      if (emitter) emitter.emit(
        'warn', 
        "couldn't parse version or date from filename: " + item.filename
      );
      return false;
    }

    var satisfied;
    if (input) satisfied = (
      semver.satisfies(item.version, input) || 
      tsm.gitCheck(input, item.git_revision)
    );

    // If there's no input, or if there is input and it was satisfied, this
    // item 'passes'
    if (!input || (input && satisfied)) return true;

    return false;
  });
};

// ### getBuilds
// * `branch` branch to get builds for
// * `done` callback function called with `(error, builds)`
//
// Get the list of builds for a particular branch
tsm.getBuilds = function (branch, done) {
  var url = branchURL.replace('$BRANCH', branch);
  request(url, function (error, response, body) { 
    try {
      if (error) throw error;
      if (response.statusCode != 200)
        throw new Error("got http " + response.statusCode);
      var data = JSON.parse(body);
      done(null, data);
    } 
    
    catch (e) { done(e); }
  });
};

// ### getAllBuilds
// * `input` git hash or version to match
// * `os` os to match, should be 'linux' or 'osx' or 'win32'
// * `done` callback function, called with `(error, builds)`
//
// Gets all builds matching the input query.  Input can be undefined in which
// case we return all builds.
tsm.getAllBuilds = function (input, os, done, emitter) {
  emitter = emitter || new EventEmitter();

  tsm.getBranches(function (error, branches) {
    async.reduce(branches, [], function (memo, item, callback) {
      emitter.emit('debug', "retrieving builds for branch: " + item);

      tsm.getBuilds(item, function (error, builds) {
        if (error) callback(error);
        else callback(null, memo.concat(builds));
      });
    }, function (error, result) {
      // Sort and return
      if (error) return done(error);

      result = tsm.parseBuildList(input, os, result);
      result.sort(function (a, b) {
        return a.date.getTime() - b.date.getTime();
      });

      done(null, result);
    });
  });

  return emitter;
};

// ### parseVersionFile
// * `data` version file text 
//
// Parses the text of a version.txt file and returns it
tsm.parseVersionFile = function (data) {
  return data.split('\n').reduce(function (memo, item) { 
    if (!item) return memo;
    // remove /r characters which may be present on windows
    item = item.replace(/\r/g, '');
    item = item.split('=');
    memo[item[0]] = item[1];
    return memo;
  }, {});
};

// ### examineDir
// * `dir` directory to examine
// * `done` callback called with `(error, data)`
//
// Tries to get the version.txt file in a directory.  If it isn't found or it
// doesn't appear to have the correct properties, an error is returned.
tsm.examineDir = function (dir, done) {
  fs.readFile(path.join(dir, 'version.txt'), 'utf8', function (error, data) {
    if (error) return done(error);
    data = tsm.parseVersionFile(data);
    if (!data.githash || !data.version || !data.timestamp)
      done(new SyntaxError('dir does not appear to contain a valid sdk'));
    else done(null, data);
  });
};

// ### findInstalled
// * `dir` directory to examine
// * `input` git hash or version to match
// * `done` callback function, called with `(error, builds)`
//
// Finds installed versions. Returns an emitter which may emit 'debug' and 'log'
// events.
tsm.findInstalled = function (dir, input, done, emitter) {
  emitter = emitter || new EventEmitter();
  fs.readdir(dir, function (error, versions) {
    if (error) return done(error);
    emitter.emit("debug", "examining directories: " + versions.join(','));
    async.reduce(versions, [], function (memo, version, callback) {
      tsm.examineDir(path.join(dir, version), function (error, build) {
        if (error) return callback(null, memo);

        emitter.emit("debug", "got data for version: " + version);

        var satisfied;
        if (input) satisfied = (
          semver.satisfies(build.version, input) || 
          tsm.gitCheck(input, build.githash)
        );

        if (!input || (input && satisfied)) {
          emitter.emit("debug", version + " satisfies, returning it");
          memo.push({
            githash: build.githash,
            version: build.version,
            date: new Date(build.timestamp),
            dir: path.join(dir, version)
          });
        }

        callback(null, memo);
      });
    }, function (error, data) {
      if (error) return done(error);

      data.sort(function (a, b) {
        return a.date.getTime() - b.date.getTime();
      });
      done(null, data);
    });
  });
  return emitter;
};

// ### mergeBuilds
// * `available` uninstalled but available builds
// * `installed` builds assumed to already be on the user's system
//
// Merges one list of available builds and one list of installed builds
tsm.mergeBuilds = function (available, installed) {

  // Setup a mapping of git hashes to build objects.
  var installedByHash = {};
  installed.forEach(function (build) { 
    installedByHash[build.githash] = build; 
  });

  // We'll loop over the available builds and delete builds from the
  // installedByHash object when we encounter them. That way, any builds not
  // present in the installed list but present in the available list will still
  // be in the installedByHash object at the end and we can simply drop those
  // on the end of the available list and return it.

  available = available.map(function (build) {
    if (installedByHash[build.githash]) build.installed = true;
    else build.installed = false;

    delete installedByHash[build.githash];
    return build;
  });

  Object.keys(installedByHash).forEach(function (hash) {
    var build = installedByHash[hash];
    build.installed = true;
    available.push(build);
  });

  available.sort(function (a, b) {
    return a.date.getTime() - b.date.getTime();
  });

  return available;
};

var oldexec = exec;
exec = function (what, callback) {
   oldexec(what, callback);
};

// ### unzip
// * `zip` zip file to extract
// * `output` output directory
// * `done` callback
//
// Extracts some zip. Should work on windows and any platform that has unzip.
tsm.unzip = function (zip, output, done) {
  if (process.platform == 'win32')
    exec("\"" + __dirname + "\\7za.exe\" x -y \"" + zip + "\" -o\"" + output + "\"", done);
  else
    exec("unzip -oqq '" + zip + "' -d '" + output + "'", done);
};