deploy.js

/* globals exec */

var async = require('async')
var _ = require('lodash')
var dir = require('node-dir')
var fs = require('fs')
var heroku = require('./deploy/heroku')
var mime = require('mime')
var request = require('request')
var util = require('util')

require('shelljs/global')

var _command = function (cmd) {
  return exec(cmd, {silent: true}).stdout.replace(/\n/, '')
}

var username = function () {
  var user = _command('git config user.email')
  if (user === '') user = process.env.DEPLOY_USER
  return user
}

var Deployer = function (app, done, log) {
  this.app = app
  this.done = done
  this.bundleExts = ['js', 'css']
  this.bundlePaths = {}
  this.log = log
  this.version = process.env.BUNDLE_VERSION

  this.awsContentUrlPrefix = process.env.AWS_S3_CONTENT_URL + '/'
}

Deployer.prototype.fail = function (err) {
  this.log.errorlns(err)
  this.done(false)
}

Deployer.prototype.upload = function (done) {
  this.log.subhead('uploading to S3')

  var s3 = new (require('aws-sdk')).S3()

  var upload = function (path, contents, type, done) {
    this.log.writeln(path)

    s3.putObject({
      Bucket: process.env.AWS_S3_BUCKET,
      Key: path,
      Body: contents,
      ACL: 'public-read',
      ContentType: type
    }, done)
  }.bind(this)

  var version = this.version

  dir.files('dist/deploy/pages', function (err, files) {
    if (err) throw err
    async.each(files, function (filename, next) {
      var contents = fs.readFileSync(filename)
      var path = filename.replace(/^dist\/deploy\/pages/, 'assets/' + version)

      upload(path, contents, mime.lookup(filename), next)
    }, done)
  })
}

Deployer.prototype.uploadSourceMap = function (callback) {
  this.log.subhead('uploading source map to Rollbar')

  var sourceMapFile = 'dist/deploy/pages/bundle.min.js.map'

  var formData = {
    // Pass a simple key-value pair
    access_token: process.env.ROLLBAR_SERVER_TOKEN,
    // Pass data via Buffers
    version: this.version,
    minified_url: this.awsContentUrlPrefix + this.bundlePaths.js,
    // Pass optional meta-data with an 'options' object with style: {value: DATA, options: OPTIONS}
    // See the `form-data` README for more information about options: https://github.com/felixge/node-form-data
    source_map: {
      value: fs.createReadStream(sourceMapFile),
      options: {
        filename: sourceMapFile,
        contentType: 'application/octet-stream'
      }
    }
  }
  request.post({
    url: 'https://api.rollbar.com/api/1/sourcemap',
    formData: formData
  }, function (err, httpResponse, body) {
    if (err || body.err > 0) {
      console.error('upload failed:', err)
      this.fail(err.message)
    }
    callback()
  }.bind(this))
}

Deployer.prototype.notifyRollbar = function (callback) {
  this.log.subhead('notifying Rollbar of deploy')

  var formData = {
    access_token: process.env.ROLLBAR_SERVER_TOKEN,
    revision: require('./deploy/version')(),
    environment: process.env.NODE_ENV,
    local_username: username()
  }
  request.post({
    url: 'https://api.rollbar.com/api/1/deploy/',
    formData: formData
  }, function (err, httpResponse, body) {
    if (err || body.err > 0) {
      this.fail(err)
    }
    callback()
  }.bind(this))
}

Deployer.prototype.updateEnv = function (callback) {
  this.log.subhead(util.format('updating BUNDLE_VERSION on %s: %s', this.app, this.version))
  heroku.config(this.app).update({BUNDLE_VERSION: this.version}, callback)
}

var api = {
  appName: function (target) {
    var name
    if (target === 'staging') {
      name = 'hylo-node-staging'
    } else if (target === 'production') {
      name = 'hylo-node'
    }
    return name
  },

  setupEnv: function (target, log, done) {
    log.subhead('setting up environment variables for deploy')

    process.env.BUNDLE_VERSION = require('./deploy/version')(8)
    log.writeln('BUNDLE_VERSION: ' + process.env.BUNDLE_VERSION)

    var appName = api.appName(target)
    var keys = [
      'NODE_ENV',
      'ASSET_HOST_URL',
      'AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_S3_BUCKET', 'AWS_S3_CONTENT_URL',
      'SLACK_APP_CLIENT_ID',
      'BRANCH_API_KEY',
      'FACEBOOK_APP_ID',
      'FILEPICKER_API_KEY',
      'GOOGLE_BROWSER_KEY', 'GOOGLE_CLIENT_ID',
      'ROLLBAR_CLIENT_TOKEN', 'ROLLBAR_SERVER_TOKEN',
      'SEGMENT_KEY', 'STRIPE_PUBLISHABLE_KEY'
    ]

    log.writeln(util.format('fetching from %s: %s', appName, keys.join(', ')))

    heroku.config(appName).info(function (err, vars) {
      _.extend(process.env, _.pick(vars, keys))
      done(err)
    })
  },

  run: function (target, done, log) {
    var deployer = new Deployer(api.appName(target), done, log)

    async.series([
      deployer.upload.bind(deployer),
      deployer.uploadSourceMap.bind(deployer),
      deployer.notifyRollbar.bind(deployer),
      deployer.updateEnv.bind(deployer)
    ], function (err) {
      if (err) {
        deployer.fail(err)
      } else {
        done()
      }
    })
  }

}

module.exports = api