heroku-rails-saas 0.1.7 → 1.0.2

data/heroku-rails-saas.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path('../lib/heroku-rails-saas/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name              = "heroku-rails-saas"
+  gem.version           = HerokuRailsSaas::VERSION
+  gem.authors           = ["Elijah Miller", "Glenn Roberts", "Jacques Crocker", "Lance Sanchez", "Chris Trinh"]
+  gem.summary           = "Deployment and configuration tools for Heroku/Rails"
+  gem.description       = "Manage multiple Heroku instances/apps for a single Rails app using Rake."
+  gem.email             = "lance.sanchez@gmail.com"
+  gem.homepage          = "http://github.com/darkbushido/heroku-rails-saas"
+  gem.rubyforge_project = "none"
+  gem.require_paths     = ["lib"]
+  gem.files             = `git ls-files | grep -Ev '^(myapp|examples)'`.split("\n")
+  gem.test_files        = `git ls-files -- spec/*`.split("\n")
+  gem.rdoc_options      = ["--charset=UTF-8"]
+  gem.extra_rdoc_files  = ["LICENSE", "README.md", "TODO", "CHANGELOG"]
+
+  gem.add_runtime_dependency "rails"
+  gem.add_runtime_dependency "heroku-api", "~> 0.3.8"
+  gem.add_runtime_dependency "netrc", "~> 0.7.7"
+  gem.add_runtime_dependency "parallel", "~> 0.6.2"
+  gem.add_runtime_dependency "rendezvous", "~> 0.0.2"
+  gem.add_development_dependency "rspec", "~> 2.0"
+  gem.add_development_dependency "webmock", "~> 1.11.0"
+end

data/lib/generators/templates/heroku.rake

@@ -2,32 +2,33 @@
 # ### e.g. rake deploy (instead of rake heroku:deploy)
 # ###
 # task :deploy =>  ["heroku:deploy"]
-# task :console => ["heroku:console"]
 # task :setup =>   ["heroku:setup"]
 # task :logs =>    ["heroku:logs"]
 # task :restart => ["heroku:restart"]
 
 # Heroku Deploy Callbacks
 namespace :heroku do
-
-  # runs before all the deploys complete
+  # Runs before all the deploys complete.
   task :before_deploy do
-
   end
 
-  # runs before each push to a particular heroku deploy environment
-  task :before_each_deploy, [:app_name] do |t,args|
-
+  # Runs before each push to a particular heroku deploy environment.
+  task :before_each_deploy, [:local_name, :remote_name, :configs] do |t, args|
   end
 
-  # runs after each push to a particular heroku deploy environment
-  task :after_each_deploy, [:app_name] do |t,args|
+  # Runs every time there is heroku deploy regardless of exceptions/failures.
+  task :ensure_each_deploy, [:local_name, :remote_name, :configs] do |t, args|
+  end
 
+  # Runs after each push to a particular heroku deploy environment
+  task :after_each_deploy, [:local_name, :remote_name, :configs] do |t, args|
   end
 
-  # runs after all the deploys complete
+  # Runs after all the deploys complete
   task :after_deploy do
-
   end
 
-end
+  # Callback for when we switch environment
+  task :switch_environment do
+  end
+end

data/lib/heroku-rails-saas.rb

@@ -1,4 +1 @@
-require 'heroku-rails-saas/config'
-require 'heroku-rails-saas/runner'
-require 'heroku-rails-saas/railtie' if defined?(::Rails::Railtie)
-require 'heroku-rails-saas/hash_recursive_merge'
+require 'heroku-rails-saas/railtie' if defined?(::Rails::Railtie)

data/lib/heroku-rails-saas/config.rb

@@ -1,9 +1,9 @@
 require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/hash/deep_merge'
 require 'erb'
 
 module HerokuRailsSaas
   class Config
-
     SEPERATOR = ":"
 
     class << self
@@ -15,7 +15,7 @@ module HerokuRailsSaas
         @heroku_rails_root = root
       end
 
-      def app_name(app, env)
+      def local_name(app, env)
         "#{app}#{SEPERATOR}#{env}"
       end
 
@@ -27,8 +27,7 @@ module HerokuRailsSaas
       def extract_name_from(app_env)
         name, env = app_env.split(SEPERATOR)
         name
-      end
-      
+      end      
     end
 
     attr_accessor :settings
@@ -44,22 +43,10 @@ module HerokuRailsSaas
     def app_names
       apps.keys
     end
-
-    def cmd(app_env)
-      if self.stack(app_env) =~ /cedar/i
-        'heroku run '
-      else
-        'heroku '
-      end
-    end
-
-    def rails_cli script
-      Rails::VERSION::MAJOR < 3 ? ".script/#{script}" : "rails #{script}"
-    end
     
-    # Returns the app name on heroku froma string format like so: `app:env`
+    # Returns the app name on heroku from a string format like so: `app:env`
     # Allows for `rake <app:env> [<app:env>] <command>`
-    def app_name_on_heroku(string)
+    def heroku_app_name(string)
       app_name, env = string.split(SEPERATOR)
       apps[app_name][env]
     end
@@ -67,7 +54,9 @@ module HerokuRailsSaas
     # return all enviromnets in this format app:env
     def app_environments(env_filter="")
       apps.each_with_object([]) do |(app, hsh), arr|
-        hsh.each { |env, app_name| arr << self.class.app_name(app, env) if (env_filter.nil? || env_filter.empty?) || env == env_filter }
+        hsh.each do |env, app_name| 
+          arr << self.class.local_name(app, env) if(env_filter.nil? || env_filter.empty? || env == env_filter)
+        end
       end
     end
 
@@ -103,7 +92,6 @@ module HerokuRailsSaas
       app_setting_hash("scale", app_env)
     end
 
-
     # return a list of collaborators for a particular app environment
     def collaborators(app_env)
       app_setting_array('collaborators', app_env)
@@ -111,18 +99,33 @@ module HerokuRailsSaas
 
     # return a list of addons for a particular app environment
     def addons(app_env)
-      app_setting_array('addons', app_env)
+      all_addons = app_setting_array('addons', app_env)
+
+      # Replace default addons tier with app specific ones.
+      addons = all_addons.each_with_object({}) do |addon, hash|
+        name, tier = addon.split(":")
+        hash[name] = tier
+      end
+
+      addons.to_a.map { |key_value| key_value.join(":") }
     end
 
-    private
+    # return the region for a particular app environment
+    def region(app_env)
+      name, env = app_env.split(SEPERATOR)
+      stacks = self.settings['region'] || {}
+      stacks[name].try("[]", env) || stacks['all']
+    end
 
+  private
     # Add app specific settings to the default ones defined in all for an array listing
     def app_setting_array(setting_key, app_env)
       name, env = app_env.split(SEPERATOR)
       setting = self.settings[setting_key] || {}
       default = setting['all'] || []
 
-      app_settings = setting[name].try("[]", env) || []
+      app_settings = Array.wrap(setting[name].try("[]", env))
+
       (default + app_settings).uniq
     end
 
@@ -159,9 +162,9 @@ module HerokuRailsSaas
     end
 
     def aggregate_heroku_configs(config_files)
-      hsh = config_files[:apps].each_with_object({}) { |file, h| h.rmerge!(parse_yml(file, :apps)) }
+      configs = config_files[:apps].each_with_object({}) { |file, h| h.deep_merge!(parse_yml(file, :apps)) }
       # overwrite all configs with the environment specific ones
-      hsh.rmerge!(parse_yml(config_files[:default], :default))
+      configs.deep_merge!(parse_yml(config_files[:default], :default))
     end
   end
 end

data/lib/heroku-rails-saas/displayer.rb

@@ -0,0 +1,26 @@
+require_relative 'helper'
+
+module HerokuRailsSaas
+  class Displayer
+    class << self
+      # Prepends a string output with a label consisting of the app name and a color code.    
+      def labelize(message="", new_line=true, remote_name, color)
+        message = "[ #{Helper.send(color, remote_name)} ] #{message}"
+        message = message + "\n" if new_line && message[-1] != "\n"
+        $stdout.print(message)
+        $stdout.flush
+      end
+    end
+
+    def initialize(remote_name, color)
+      @remote_name = remote_name
+      @color = color
+    end
+
+    attr_reader :color, :remote_name
+
+    def labelize(message="", new_line=true)
+      self.class.labelize(message, new_line, @remote_name, @color)
+    end
+  end
+end

data/lib/heroku-rails-saas/helper.rb

@@ -0,0 +1,67 @@
+require_relative 'displayer'
+
+module HerokuRailsSaas
+  module Helper
+    COLORS = %w(cyan yellow green magenta red)
+    COLOR_CODES = {
+      "red"     => 31,
+      "green"   => 32,
+      "yellow"  => 33,
+      "magenta" => 35,
+      "cyan"    => 36,
+    }
+    
+    class << self
+      COLORS.each do |color|
+        define_method(color.to_sym) { |string| colorize(string, COLOR_CODES[color]) }
+      end
+
+      # Implementation from https://github.com/heroku/heroku/blob/master/lib/heroku/helpers.rb for consistency. 
+      @@kb = 1024
+      @@mb = 1024 * @@kb
+      @@gb = 1024 * @@mb
+      def format_bytes(amount)
+        amount = amount.to_i
+        return '(empty)' if amount == 0
+        return amount if amount < @@kb
+        return "#{(amount / @@kb).round}k" if amount < @@mb
+        return "#{(amount / @@mb).round}M" if amount < @@gb
+        return "#{(amount / @@gb).round}G"
+      end
+
+      # Implementation from https://github.com/heroku/heroku/blob/master/lib/heroku/helpers.rb for consistency.
+      def styled_hash(hash, displayer)
+        max_key_length = hash.keys.map {|key| key.to_s.length}.max + 2
+        keys ||= hash.keys.sort {|x,y| x.to_s <=> y.to_s}
+        keys.each do |key|
+          case value = hash[key]
+          when Array
+            if value.empty?
+              next
+            else
+              elements = value.sort {|x,y| x.to_s <=> y.to_s}
+              displayer.labelize("#{key}: ".ljust(max_key_length), false)
+              puts elements[0]
+              elements[1..-1].each do |element|
+                displayer.labelize("#{' ' * max_key_length}#{element}")
+              end
+              if elements.length > 1
+                displayer.labelize
+              end
+            end
+          when nil
+            next
+          else
+            displayer.labelize("#{key}: ".ljust(max_key_length), false)
+            puts value
+          end
+        end
+      end
+
+    private
+      def colorize(string, color_code)
+        "\e[#{color_code}m#{string}\e[0m"
+      end
+    end
+  end
+end

data/lib/heroku-rails-saas/heroku_client.rb

@@ -0,0 +1,54 @@
+require 'heroku-api'
+require 'netrc'
+require 'json'
+
+require_relative 'helper'
+
+module HerokuRailsSaas
+  class HerokuClient
+    HEROKU_API_HOST = "api.heroku.com"
+
+    def initialize
+      @user, @api_token = netrc[HEROKU_API_HOST]
+      @heroku = Heroku::API.new(:api_key => @api_token)
+    end
+
+    attr_accessor :user, :heroku, :api_token
+
+  private
+    # Redirects method calls to the Heroku::API client, parse the JSON and returns the body.
+    def method_missing(method_name, *args, &block)
+      begin
+        response = @heroku.__send__(method_name.to_sym, *args, &block)
+        response.body
+      rescue Heroku::API::Errors::ErrorWithResponse => error
+        message = error.response.status == 404 ? "#{Helper.yellow(args[0])} does not exists" : JSON.parse(error.response.body)["error"]
+        status = error.response.headers["Status"]
+
+        raise <<-OUTPUT
+              #{Helper.red(error.class)}:
+                Status: #{status}
+                Message: #{message}
+              OUTPUT
+      end
+    end
+
+    def netrc # :nodoc:
+      @netrc ||= begin
+        File.exists?(netrc_path) ? Netrc.read(netrc_path) : raise(StandardError)
+      rescue => error
+        raise ".netrc missing or no entry found. Try `heroku auth:login`"
+      end
+    end
+
+    def netrc_path # :nodoc:
+      default = Netrc.default_path
+      encrypted = default + ".gpg"
+      if File.exists?(encrypted)
+        encrypted
+      else
+        default
+      end
+    end
+  end
+end

data/lib/heroku-rails-saas/railtie.rb

@@ -1,8 +1,14 @@
+require_relative 'config'
+require_relative 'runner'
+
 module HerokuRailsSaas
   class Railtie < ::Rails::Railtie
     rake_tasks do
       HerokuRailsSaas::Config.root = ::Rails.root
-      load 'heroku/rails/tasks.rb'
+      if ::Rails.env.development?
+        puts "Load heroku-rails-saas rake task"
+        load 'heroku/rails/tasks.rb'
+      end
     end
   end
-end
+end

data/lib/heroku-rails-saas/runner.rb

@@ -1,247 +1,531 @@
 require 'active_support/core_ext/object/blank'
-require 'heroku/client'
+require 'parallel'
+
+require_relative 'heroku_client'
+require_relative 'helper'
+require_relative 'displayer'
 
 module HerokuRailsSaas
   class Runner
+    extend Forwardable
+
+    DATABASE_REGEX = /heroku-postgresql|shared-database|heroku-shared-postgresql|amazon_rds/
+    DEFAULT_HEROKU_DOMAIN = /\.herokuapp\.com\Z/
+    SHARED_DATABASE_ADDON = "shared-database:5mb"
+    CONFIG_DELETE_MARKER = "DELETE"
+    LOCAL_CA_FILE = File.expand_path('../../data/cacert.pem', __FILE__)
+
+    class << self
+      # Returns an array of :add and :delete deltas respectively.
+      def deltas(local, remote)
+        [local - remote, remote - local]
+      end
+    end
+
     def initialize(config)
       @config = config
-      @environments = []
+      @local_names = []
+      @displayer = nil
+      @assigned_colors = {}
     end
 
-    def authorize
-      @heroku ||= Heroku::Client.new(*Heroku::Auth.get_credentials)
+    def_delegator :@displayer, :labelize
+
+    # App/Environment methods
+    #---------------------------------------------------------------------------------------------------------------------
+    #
+    def heroku
+      @heroku ||= HerokuClient.new
+    end
+
+    def add_app(local_name)
+      @local_names << local_name
     end
 
-    # add a specific environment to the run list
-    def add_environment(env)
-      @environments << env
+    def add_environment(environment)
+      @local_names = @config.app_environments(environment)
     end
 
-    # use all environments or filter out production environments
+    # Set filter to true to filter out all production environments.
     def all_environments(filter=false)
-      @environments = @config.app_environments
-      filter ? @environments.reject! { |app| app[regex_for(:production)] } : @environments
+      @local_names = @config.app_environments
+      filter ? @local_names.reject! { |local_name| local_name[regex_for(:production)] } : @local_names
     end
 
-    # use all heroku apps filtered by environments
-    def environments(env)
-      @environments = @config.app_environments(env)
+    # Setup methods
+    #---------------------------------------------------------------------------------------------------------------------
+    #
+    def setup_app
+      each_heroku_app do |local_name, remote_name|
+        _setup_app(local_name, remote_name)
+      end
     end
 
-    # setup apps (create if necessary)
-    def setup_apps
-      authorize unless @heroku
+    def setup_stack
+      each_heroku_app do |local_name, remote_name|
+        remote_stack  = heroku.get_stack(remote_name).select { |stack| stack["current"] }.first["name"]
+        local_stack   = @config.stack(local_name)
 
-      # get a list of all my current apps on Heroku (so we don't create dupes)
-      @my_apps = @heroku.list.map{|a| a.first}
+        if local_stack != remote_stack
+          puts "Migrating the app: #{remote_name} to the stack: #{local_stack}"
+          heroku.put_stack(remote_name, local_stack)
+        end
+      end
+    end
+
+    def setup_collaborators
+      each_heroku_app do |local_name, remote_name|
+        _setup_collaborators(local_name, remote_name)
+      end
+    end
 
-      each_heroku_app do |heroku_env, app_name, repo|
-        next if @my_apps.include?(app_name)
+    def setup_addons
+      each_heroku_app do |local_name, remote_name|
+        _setup_addons(local_name, remote_name)
+      end
+    end
 
-        options = { :remote => app_name, :stack => @config.stack(heroku_env) }
+    def setup_config
+      each_heroku_app do |local_name, remote_name|
+        _setup_config(local_name, remote_name)
+      end
+    end
 
-        @heroku.create(app_name, options)
+    def setup_domains
+      each_heroku_app do |local_name, remote_name|
+        _setup_domains(local_name, remote_name)
       end
     end
 
-    # setup the stacks for each app (migrating if necessary)
-    def setup_stacks
-      authorize unless @heroku
-      each_heroku_app do |heroku_env, app_name, repo|
-        # get the intended stack setting
-        stack = @config.stack(heroku_env)
+    # Action methods
+    #---------------------------------------------------------------------------------------------------------------------
+    #
+    def deploy
+      require 'pty'
+
+      Rake::Task["heroku:before_deploy"].invoke
+
+      deploy_branch = prompt_for_branch
 
-        # get the remote info about the app from heroku
-        heroku_app_info = @heroku.info(app_name) || {}
+      each_heroku_app do |local_name, remote_name|
+        @displayer.labelize("Deploying to #{remote_name}...")
+
+        configs = @config.config(local_name)
+
+        Rake::Task["heroku:before_each_deploy"].reenable
+        Rake::Task["heroku:before_each_deploy"].invoke(local_name, remote_name, configs)
+
+        begin
+          raise "Server not setup run `rake #{local_name} heorku:setup`" if _setup_app?(remote_name)
+
+          repo = heroku.get_app(remote_name)["git_url"]
+
+          # The use of PTY here is because we can't depend on the external process 'git' to flush its
+          # buffered output to STDOUT, using PTY we can mimic a terminal and trick 'git' into periodically flushing
+          # it's output. 
+          # NOTE: The process bar in 'git' doesn't render correct since it tries to re-render the same line while
+          # other proceess are trying to do the same.
+          # ^0 is required so git dereferences the tag into a commit SHA (else Heroku's git server will throw up)
+          # See https://github.com/TerraCycleUS/heroku-rails-saas/commit/25cbcd3d79fe74e4e54297df1022a39bdd104668
+          PTY.spawn("git push #{repo} --force #{deploy_branch}^0:refs/heads/master") do |read_io, _, pid|
+            begin
+              read_io.sync = true
+              read_io.each { |line| @displayer.labelize(line) }
+              Process.wait(pid)
+            rescue Errno::EIO
+            end
+          end
+
+          if continue = $?.exitstatus
+            _maintenance(true, remote_name)
+            _setup_collaborators(local_name, remote_name)
+            _setup_addons(local_name, remote_name)
+            _setup_domains(local_name, remote_name)
+            _setup_config(local_name, remote_name)
+            _migrate(remote_name)
+            _scale(local_name, remote_name)
+            _restart(remote_name)
+            _maintenance(false, remote_name)
+          end
+        rescue Interrupt
+          @displayer.labelize("!!! Interrupt issued stopping deployment")
+        rescue Exception => error
+          @displayer.labelize("!!! Error deploying: #{Helper.red(error.message)}")
+          continue = false
+        ensure
+          Rake::Task["heroku:ensure_each_deploy"].reenable
+          Rake::Task["heroku:ensure_each_deploy"].invoke(local_name, remote_name, configs)
+        end
 
-        # if the stacks don't match, then perform a migration
-        if stack != heroku_app_info[:stack]
-          puts "Migrating the app: #{app_name} to the stack: #{stack}"
-          creation_command "heroku stack:migrate #{stack} --app #{app_name}"
+        if continue
+          Rake::Task["heroku:after_each_deploy"].reenable
+          Rake::Task["heroku:after_each_deploy"].invoke(local_name, remote_name, configs)
         end
       end
+
+      Rake::Task["heroku:after_deploy"].invoke
     end
 
-    # setup the list of collaborators
-    def setup_collaborators
-      authorize unless @heroku
-      each_heroku_app do |heroku_env, app_name, repo|
-        # get the remote info about the app from heroku
-        heroku_app_info = @heroku.info(app_name) || {}
-
-        # get the intended list of collaborators to add
-        collaborator_emails = @config.collaborators(heroku_env)
-
-        # add current user to collaborator list (always)
-        collaborator_emails << @heroku.user unless collaborator_emails.include?(@heroku.user)
-        collaborator_emails << heroku_app_info[:owner] unless collaborator_emails.include?(heroku_app_info[:owner])
-
-        # get existing collaborators
-        existing_emails = heroku_app_info[:collaborators].to_a.map{|c| c[:email]}
-
-        # get the list of collaborators to delete
-        existing_emails.each do |existing_email|
-          # check to see if we need to delete this person
-          unless collaborator_emails.include?(existing_email)
-            # delete that collaborator if they arent on the approved list
-            destroy_command "heroku sharing:remove #{existing_email} --app #{app_name}"
-          end
-        end
+    def exec_on_all(command)
+      each_heroku_app do |_, remote_name|
+        async_exec(remote_name, command)
+      end
+    end
+
+    # Triggers an one-off process.
+    def async_exec(remote_name, command)
+      result = heroku.post_ps(remote_name, command)
+      @displayer.labelize("[async] " + Helper.green(result["command"]))
+    end
+
+    # Triggers an one-off process and waits for the job to complete.
+    def sync_exec(remote_name, command)
+      result = heroku.post_ps(remote_name, command)
+      process_id = result["id"]
+      @displayer.labelize("[sync] " + Helper.green(result["command"]))
+      begin
+        sleep 1
+        running_process_ids = heroku.get_ps(remote_name).map { |ps| ps["id"] }
+      end while running_process_ids.include?(process_id)
+    end
+
+    def apps
+      each_heroku_app do |local_name, remote_name|
+        repo = heroku.get_app(remote_name)["git_url"]
+        puts "#{Helper.red(local_name)} maps to the Heroku app #{Helper.yellow(remote_name)}:"
+        puts "  #{Helper.green(repo)}"
+        puts
+      end
+    end
 
-        # get the list of collaborators to add
-        collaborator_emails.each do |collaborator_email|
-          # check to see if we need to add this person
-          unless existing_emails.include?(collaborator_email)
-            # add the collaborator if they are not already on the server
-            creation_command "heroku sharing:add #{collaborator_email} --app #{app_name}"
+    # Implementation from https://raw.github.com/heroku/heroku/master/lib/heroku/command/apps.rb to be consistent with our output.
+    # See Helper#styled_hash for further implemention details.
+    def info
+      each_heroku_app do |_, remote_name|
+        app_data = heroku.get_app(remote_name)
+
+        addons = heroku.get_addons(remote_name).map { |addon| addon['name'] }.sort
+        collaborators = heroku.get_collaborators(remote_name).map { |collaborator| collaborator['email'] }.sort
+        collaborators.reject! { |email| email == app_data['owner_email'] }
+
+        data = {:name => remote_name}
+        data["Addons"] = addons if addons.present?
+        data["Collaborators"] = collaborators
+        data["Create Status"] = app_data["create_status"] if app_data["create_status"] && app_data["create_status"] != "complete"
+        data["Database Size"] = Helper.format_bytes(app_data["database_size"]) if app_data["database_size"]
+        data["Git URL"] = app_data["git_url"]
+        data["Database Size"].gsub!('(empty)', '0K') + " in #{quantify("table", app_data["database_tables"])}" if app_data["database_tables"]
+
+        if app_data["dyno_hours"].is_a?(Hash)
+          data["Dyno Hours"] = app_data["dyno_hours"].keys.map do |type|
+            "%s - %0.2f dyno-hours" % [ type.to_s.capitalize, app_data["dyno_hours"][type] ]
           end
         end
 
-        # display the destructive commands
-        output_destroy_commands(app_name)
+        data["Owner Email"] = app_data["owner_email"]
+        data["Region"] = app_data["region"] if app_data["region"]
+        data["Repo Size"] = Helper.format_bytes(app_data["repo_size"]) if app_data["repo_size"]
+        data["Slug Size"] = Helper.format_bytes(app_data["slug_size"]) if app_data["slug_size"]
+        data["Stack"] = app_data["stack"]
+        data.merge!("Dynos" => app_data["dynos"], "Workers" => app_data["workers"]) if data["Stack"] != "cedar"
+        data["Web URL"] = app_data["web_url"]
+        data["Tier"] = app_data["tier"].capitalize if app_data["tier"]
+
+        Helper.styled_hash(data, @displayer)
+      end  
+    end
+
+    def maintenance(toggle)
+      each_heroku_app do |_, remote_name|
+        _maintenance(toggle, remote_name)
+      end 
+    end
+
+    def restart
+      each_heroku_app do |_, remote_name|
+        _restart(remote_name)
       end
     end
 
-    # setup configuration
-    def setup_config
-      authorize unless @heroku
-      each_heroku_app do |app_env, app_name, repo|
-        # get the configuration that we are aiming towards
-        new_config = @config.config(app_env)
-
-        # default RACK_ENV and RAILS_ENV to the heroku_env (unless its manually set to something else)
-        new_config["RACK_ENV"]  = HerokuRailsSaas::Config.extract_environment_from(app_env) unless new_config["RACK_ENV"]
-        new_config["RAILS_ENV"] = HerokuRailsSaas::Config.extract_environment_from(app_env) unless new_config["RAILS_ENV"]
-        # get the existing config from heroku's servers
-        existing_config = @heroku.config_vars(app_name) || {}
-
-        # find the config variables to add
-        add_config = {}
-        new_config.each do |new_key, new_val|
-          add_config[new_key] = new_val unless existing_config[new_key] == new_val
-        end
+    def scale
+      each_heroku_app do |local_name, remote_name|
+        _scale(local_name, remote_name)
+      end
+    end
 
-        # persist the changes onto heroku
-        unless add_config.empty?
-          # add the config
-          set_config = ""
-          add_config.each do |key, val|
-            set_config << "#{key}='#{val}' "
-          end
-          creation_command "heroku config:add #{set_config} --app #{app_name}"
+    def logs
+      each_heroku_app do |_, remote_name|
+        _logs(remote_name)
+      end
+    end
+
+    # NOTE: This doesn't work with more than one environment. My guess is that each process triggers STDIN to flush
+    # its buffer causing it to act very strange. A possible solution is to have a master process (or the current rake
+    # process) to control the flow of input data via an IO pipe.
+    def console
+      require 'rendezvous'
+
+      each_heroku_app do |_, remote_name|
+        _console(remote_name)
+      end
+    end
+
+    # Helper methods
+    #---------------------------------------------------------------------------------------------------------------------
+    #
+    # Cycles through each heroku app and yield the local app name and the heroku app name. This will fork and create another 
+    # child process for each heorku app.
+    def each_heroku_app
+      process_heroku_command do |local_names|
+        $stdout.sync = true # Sync up the bufferred output.
 
-          # This fails on a newly created app
-          system_with_echo("#{@config.cmd(app_env)} \"#{@config.rails_cli(:runner)} 'Rails.cache.clear'\" --app #{app_name}")
+        # Preload the colors before we parallelize any commands.
+        local_names.each do |local_name|
+          @assigned_colors[local_name] ||= Helper::COLORS[@assigned_colors.size % Helper::COLORS.size]
+        end
+
+        # Performs work in 4 processes, each process is tasked the same command but for a different 
+        # heroku environment. 
+        # We use processes to get around the GIL/GVL issues. 
+        Parallel.each(local_names, :in_processes => 4) do |local_name|
+          remote_name = @config.heroku_app_name(local_name)
+          @displayer = Displayer.new(remote_name, @assigned_colors[local_name])
+          yield(local_name, remote_name)
         end
       end
     end
 
-    # setup the addons for heroku
-    def setup_addons
-      authorize unless @heroku
-      each_heroku_app do |heroku_env, app_name, repo|
-        # get the addons that we are aiming towards
-        addons = @config.addons(heroku_env)
-
-        # get the addons that are already on the servers
-        existing_addons = (@heroku.installed_addons(app_name) || []).map{|a| a["name"]}
-
-        # all apps need the shared database
-        addons << "shared-database:5mb" unless addons.any? {|x| x[/heroku-postgresql|shared-database|heroku-shared-postgresql|amazon_rds/]}
-
-        # remove the addons that need to be removed
-        existing_addons.each do |existing_addon|
-          # check to see if we need to delete this addon
-          unless addons.include?(existing_addon)
-            # delete this addon if they arent on the approved list
-            destroy_command "heroku addons:remove #{existing_addon} --app #{app_name} --confirm #{app_name}"
-          end
+    # Internal methods
+    #---------------------------------------------------------------------------------------------------------------------
+    #
+  private
+    def _setup_app(local_name, remote_name)
+      if _setup_app?(remote_name)
+        params = {'name' => remote_name}
+        region = @config.region(local_name)
+
+        @displayer.labelize("Creating Heroku app: #{Helper.green(remote_name)}")
+
+        if region.present?
+          params.merge!('region' => region)
+          @displayer.labelize("\t Region: #{Helper.green(region)}")
         end
 
-        # add the addons that dont exist already
-        addons.each do |addon|
-          # check to see if we need to add this addon
-          unless existing_addons.include?(addon)
-            # add this addon if they are not already added
-            creation_command "heroku addons:add #{addon} --app #{app_name}"
+        heroku.post_app(params)
+      end
+    end
+
+    def _setup_app?(remote_name)
+      !heroku.get_apps.any? { |apps| apps["name"] == remote_name }
+    end
+
+    def _setup_collaborators(local_name, remote_name)
+      @displayer.labelize("Setting collaborators... ")
+      
+      remote_collaborators = heroku.get_collaborators(remote_name).map { |collaborator| collaborator["email"] }
+      local_collaborators  = @config.collaborators(local_name)
+
+      add_collaborators, delete_collaborators = self.class.deltas(local_collaborators, remote_collaborators)
+      apply(remote_name, add_collaborators, "post_collaborator", "Adding collaborator(s):")
+      apply(remote_name, delete_collaborators, "delete_collaborator", "Deleting collaborator(s):")
+    end
+
+    def _setup_addons(local_name, remote_name)
+      @displayer.labelize("Setting addons... ")
+
+      remote_addons = heroku.get_addons(remote_name).map { |addon| addon["name"] }
+      local_addons  = @config.addons(local_name)
+
+      # Requires at the minimum a shared database.
+      local_addons << SHARED_DATABASE_ADDON unless local_addons.any? {|x| x[DATABASE_REGEX] }
+
+      add_addons, delete_addons = self.class.deltas(local_addons, remote_addons)
+      apply(remote_name, add_addons, "post_addon", "Adding addon(s):")
+      apply(remote_name, delete_addons, "delete_addon", "Deleting addon(s):")
+    end
+
+    def _setup_config(local_name, remote_name)
+      @displayer.labelize("Setting config... ")
+
+      remote_configs = heroku.get_config_vars(remote_name)
+      local_configs = @config.config(local_name)
+
+      delete_config_keys = []
+      add_configs = local_configs.delete_if do |key, value| 
+        if value == CONFIG_DELETE_MARKER
+          delete_config_keys << key
+        elsif remote_configs.has_key?(key) && remote_configs[key] == value.to_s
+          true
+        end 
+      end
+
+      perform_delete = delete_config_keys.present? && 
+                       remote_configs.keys.any? { |key| delete_config_keys.include?(key) }
+
+      if add_configs.present?
+        @displayer.labelize("Adding config(s):")
+        add_configs.each do |key, value|
+          if value.is_a?(String) && value.include?("\n")
+            configs_values = value.split("\n")
+            @displayer.labelize("#{key.rjust(25)}: #{configs_values.shift}")
+            configs_values.each { |v| @displayer.labelize("#{''.rjust(25)} #{v}") }
+          else  
+            @displayer.labelize("#{key.rjust(25)}: #{value}")
           end
         end
+        heroku.put_config_vars(remote_name, add_configs)
+      end
 
-        # display the destructive commands
-        output_destroy_commands(app_name)
+      if perform_delete
+        @displayer.labelize("Deleting config(s):")
+        delete_config_keys.each do |key| 
+          @displayer.labelize("#{key.rjust(25)}: #{remote_configs[key]}")
+          heroku.delete_config_var(remote_name, key) 
+        end
       end
     end
 
-    # setup the domains for heroku
-    def setup_domains
-      authorize unless @heroku
-      each_heroku_app do |heroku_env, app_name, repo|
-        # get the domains that we are aiming towards
-        domains = @config.domains(heroku_env)
-
-        # get the domains that are already on the servers
-        existing_domains = (@heroku.list_domains(app_name) || []).map{|a| a[:domain]}
-
-        # remove the domains that need to be removed
-        existing_domains.each do |existing_domain|
-          # check to see if we need to delete this domain
-          unless domains.include?(existing_domain)
-            # delete this domain if they arent on the approved list
-            destroy_command "heroku domains:remove #{existing_domain} --app #{app_name}"
+    def _setup_domains(local_name, remote_name)
+      @displayer.labelize("Setting domains... ")
+
+      remote_domains = heroku.get_domains(remote_name).map { |domain| domain["domain"] }
+      local_domains  = @config.domains(local_name)
+      add_domains, delete_domains = self.class.deltas(local_domains, remote_domains)
+
+      delete_domains.delete_if { |domain| domain =~ DEFAULT_HEROKU_DOMAIN }
+
+      apply(remote_name, add_domains, "post_domain", "Adding domain(s):")
+      apply(remote_name, delete_domains, "delete_domain", "Deleting domain(s):")
+    end
+
+    def _maintenance(toggle, remote_name)
+      value   = toggle ? '1' : 0
+      display = toggle ? Helper.green("ON") : Helper.red("OFF")
+      @displayer.labelize("Maintenance mode #{display}")
+      heroku.post_app_maintenance(remote_name, value)
+    end
+
+    def _restart(remote_name)
+      heroku.post_ps_restart(remote_name)
+      @displayer.labelize("Restarting... #{Helper.green('OK')}")
+    end
+
+    def _migrate(remote_name)
+      sync_exec(remote_name, "rake db:migrate")
+    end
+
+    def _scale(local_name, remote_name)
+      scaling = @config.scale(local_name)
+      types = scaling.keys
+      
+      # Clock must be the last process to scale because it could require a worker dyno to be present
+      # since it can trigger a scheduling of a background job immediately after its state is up.
+      types << types.delete("clock")
+      types.each { |type| heroku.post_ps_scale(remote_name, type, scaling[type]) }
+      @displayer.labelize("Scaling ... #{Helper.green('OK')}")
+    end
+
+    def _logs(remote_name)
+      url = heroku.get_logs(remote_name, {:tail => 1})
+      uri  = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        if ENV["HEROKU_SSL_VERIFY"] == "disable"
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.ca_file = LOCAL_CA_FILE
+          http.verify_callback = lambda do |preverify_ok, ssl_context|
+            if (!preverify_ok) || ssl_context.error != 0
+              @displayer.labelize("WARNING: Unable to verify SSL certificate for #{host}\nTo disable SSL verification, run with HEROKU_SSL_VERIFY=disable")
+            end
+            true
           end
         end
+      end
 
-        # add the domains that dont exist already
-        domains.each do |domain|
-          # check to see if we need to add this domain
-          unless existing_domains.include?(domain)
-            # add this domain if they are not already added
-            creation_command "heroku domains:add #{domain} --app #{app_name}"
+      http.read_timeout = 60 * 60 * 24
+
+      begin
+        http.start do
+          http.request_get(uri.path + (uri.query ? "?" + uri.query : "")) do |request|
+            request.read_body do |chunk|
+              chunk.split("\n").each { |line| @displayer.labelize(line) }
+            end
           end
         end
-
-        # display the destructive commands
-        output_destroy_commands(app_name)
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
+        @displayer.labelize("Could not connect to logging service")
+      rescue Timeout::Error, EOFError
+        @displayer.labelize("\nRequest timed out")
       end
     end
 
-    def scale
-      authorize unless @heroku
-      each_heroku_app do |heroku_env, app_name, repo|
-        scaling = @config.scale(heroku_env)
-        scaling.each do |process_name, instance_count|
-          begin
-            puts "Scaling app #{app_name} process #{process_name} to #{instance_count}"
-            response = @heroku.ps_scale(app_name, {:type => process_name, :qty => instance_count })
-            puts "Response: #{response}"
-          rescue => e
-            puts "Failed to scale #{app_name}. Error: #{e.inspect}"
+    def _console(remote_name)
+      data = heroku.post_ps(remote_name, 'console', {:attach => true})
+
+      Rendezvous.start(:url => data['rendezvous_url'])
+    end
+
+    # Prompt for a branch tag if any of the environments being deploy to is production grade.
+    # This serves as a sanity check against deploy directly to production environments. 
+    def prompt_for_branch
+      deploy_branch = nil
+
+      if @local_names.any? {|local_name| local_name[regex_for(:production)] }
+        all_tags = `git tag`
+        target_tag = `git describe --tags --abbrev=0`.chomp # Set latest tag as default
+
+        begin
+          puts "\nGit tags:"
+          puts all_tags
+          print "\nPlease enter a tag to deploy (or hit Enter for \"#{target_tag}\"): "
+          input_tag = STDIN.gets.chomp
+          if input_tag.present?
+            if all_tags[/^#{input_tag}\n/].present?
+              target_tag = input_tag
+              invalid = false
+            else
+              puts "\n\nInvalid git tag!"
+              invalid = true
+            end
           end
+        end while invalid
+
+        if target_tag.empty?
+          puts "Unable to determine the tag to deploy."
+          exit(1)
+        end
+
+        deploy_branch = target_tag
+      else
+        deploy_branch = `git branch`.scan(/^\* (.*)\n/).flatten.first.to_s
+        
+        if deploy_branch.empty?
+          puts "Unable to determine the current git branch, please checkout the branch you'd like to deploy."
+          exit(1) 
         end
       end
+
+      deploy_branch
     end
 
-    # cycles through each configured heroku app
-    # yields the environment name, the app name, and the repo url
-    def each_heroku_app
-      if @config.apps.size == 0
-        puts "\nNo heroku apps are configured. Run:
-          rails generate heroku:config\n\n"
+    # Checks to see if there is at least one environment indicated to run commands against.
+    def process_heroku_command
+      if @config.apps.blank?
+        puts "\nNo heroku apps are configured. Run: rails generate heroku:config\n\n"
         puts "this will generate a default config/heroku.yml that you should edit"
         puts "and then try running this command again"
 
         exit(1)
       end
 
-      if (@environments.nil? || @environments.empty?) && @config.apps.size == 1
-        @environments = [all_environments(true).try(:first)].compact
-      end
+      @local_names = [all_environments(true).try(:first)].compact if @local_names.empty?
 
-      if @environments.present?
-        @environments.each do |env|
-          app_name = @config.app_name_on_heroku(env)
-          yield(env, app_name, "git@heroku.com:#{app_name}.git")
-        end
+      if @local_names.present?
+        yield(@local_names)
       else
         puts "\nYou must first specify at least one Heroku app:
           rake <app>:<environment> [<app>:<environment>] <command>
@@ -255,45 +539,28 @@ module HerokuRailsSaas
       end
     end
 
-    def system_with_echo(*args)
-      puts args.join(' ')
-      command(*args)
-    end
-
-    def creation_command(*args)
-      system_with_echo(*args)
-    end
-
-    def destroy_command(*args)
-      # puts args.join(' ')
-      @destroy_commands ||= []
-      @destroy_commands << args.join(' ')
-    end
-
-    def output_destroy_commands(app)
-      if @destroy_commands.try(:any?)
-        puts "The #{app} had a few things removed from the heroku.yml."
-        puts "If they are no longer neccessary, then run the following commands:\n\n"
-        @destroy_commands.each do |destroy_command|
-          puts destroy_command
+    # Apply heroku configurations changes.
+    #   app      - name of the remote heroku app.
+    #   settings - list to apply method to.
+    #   method   - name of the api method to call.
+    #   message  - display of what actions are to be performed.
+    def apply(app, settings, method, message)
+      if settings.present?
+        @displayer.labelize(message)
+        settings.each do |setting|
+          @displayer.labelize("\t#{setting}")
+          heroku.__send__(method.to_sym, app, setting)
         end
-        puts "\n\nthese commands may cause data loss so make sure you know that these are necessary"
       end
-      # clear destroy commands
-      @destroy_commands = []
     end
 
-    def command(*args)
-      raise "*** command \"#{args.join ' '}\" failed" unless system(*args)
-    end
-
-    def regex_for env
-      match = case env
+    # Returns a regex to look for a specific type of an environment.
+    def regex_for(environment)
+      match = case environment
         when :production then "production|prod|live"
         when :staging    then "staging|stage"
       end
       Regexp.new("#{@config.class::SEPERATOR}(#{match})")
     end
-
   end
 end