hr_deploy 0.0.2 → 0.0.6

data/lib/hr_deploy/deployer.rb

@@ -1,387 +1,340 @@
+require 'hr_deploy/config_handler'
+require 'hr_deploy/color.rb'
+require 'hr_deploy/tasks/check_network_task'
+require 'hr_deploy/tasks/check_heroku_task'
+require 'hr_deploy/tasks/enable_pinger_task'
+require 'hr_deploy/tasks/disable_pinger_task'
+require 'hr_deploy/tasks/enable_maintenance_task'
+require 'hr_deploy/tasks/disable_maintenance_task'
+require 'hr_deploy/tasks/backup_db_task'
+require 'hr_deploy/tasks/clean_old_assets_task.rb'
+require 'hr_deploy/tasks/clean_new_assets_task.rb'
+require 'hr_deploy/tasks/precompile_assets_task.rb'
+require 'hr_deploy/tasks/push_code_task.rb'
+require 'hr_deploy/tasks/migrate_db_task.rb'
+require 'hr_deploy/tasks/restart_task.rb'
+
 module HR_Deploy
 
   class Deployer
 
-    DEBUG = false
-
-    attr_reader :target
-    attr_reader :pinging_interaction
-    attr_reader :perform_db_backup
-    attr_reader :confirm
-
-    def initialize(target, confirm)
-      @target = target
-      @pinging_interaction = target.requires_pinging_interaction?
-      @perform_db_backup = target.backup_db?
-      @confirm = confirm
+    def initialize
+      @target = nil
+      @confirm = nil
+      @dry_run = nil
+      @start_time = nil
+      @tasks_to_run = []
+      @finished_tasks = []
     end
 
-    def deploy
-      confirm_deploy
-
-      start_time = Time.now
-      puts "#{target.description} deploy started at #{Time.now.strftime('%H:%M:%S')}"
-      puts
+    def deploy(target_name, confirm, dry_run, db_change)
 
-      check_connectivity
-      check_heroku_status
+      self.confirm = confirm
+      self.dry_run = dry_run
+      self.db_change = db_change
 
-      if pinging_interaction
-        disable_pinging
-        continue?(:disabling_pinger) { enable_maintenance }
-      else
-        enable_maintenance
+      unless HR_Deploy::ConfigHandler.config_exists?
+        puts "No deployment config is present. Run 'hr_deploy generate' to generate a config example"
+        exit 1
       end
 
-      if perform_db_backup
-        continue?(:enabling_maintenance) { backup_db }
-        continue?(:backing_up_db) { push_code }
-      else
-        continue?(:enabling_maintenance) { push_code }
-      end
+      config_handler = HR_Deploy::ConfigHandler.new
 
-      continue?(:pushing_code) { migrate_db }
-      continue?(:migrating_db) { restart }
+      # This will set up targets or error in 'config_handler'
+      config_handler.attempt_to_load_targets
 
-      if pinging_interaction
-        continue?(:restarting) { enable_pinging }
-        continue?(:enabling_pinger) { disable_maintenance }
-      else
-        continue?(:restarting) { disable_maintenance }
-      end
+      if config_handler.error
+        puts config_handler.error
+        exit 1
 
-      continue?(:disabling_maintenance) do
-        puts 'Waiting 10 seconds for application to go live...'
-        sleep 10
-        puts 'Opening application...'
-        execute_system_command("heroku open --remote #{target.name}")
-        puts
+      else
+        if target_name == nil
 
-        puts "Deploy completed in #{(Time.now - start_time).round} seconds"
-      end
-    end
+          # Deploy to default target
+          default_targets = config_handler.targets.find_all { |target| target.default? }
+          if default_targets.count == 0
 
-    private
+            puts 'No default target specified. Edit config to specify one'
+            exit 1
+          elsif default_targets.count > 1
 
-    def confirm_deploy
-      answered = false
-
-      until answered
-        print "Deploy to #{target.description}? (Yes / No) > "
-        answer = $stdin.gets.chomp
+            puts 'Multiple default targets specified. Edit config to specify only one'
+            exit 1
+          else
 
-        if answer == 'Yes' || answer == 'yes'
-          answered = true
-          puts
-        elsif answer == 'No' || answer == 'no'
-          abort_deploy(nil)
+            self.target = default_targets.first
+            deploy_to_target
+          end
         else
-          puts 'Unknown answer'
-          puts
+
+          target = config_handler.targets.find { |target| target.name == target_name }
+          if target
+            self.target = target
+            deploy_to_target
+          else
+            puts "No such target: #{target_name}"
+            exit 1
+          end
         end
       end
     end
 
-    def abort_deploy(message, stage = nil)
+    private
 
-      if stage
-        puts 'Notes:'
-        puts
+    attr_accessor :target
+    attr_accessor :confirm
+    attr_accessor :dry_run
+    attr_accessor :db_change
+    attr_accessor :start_time
+    attr_reader :tasks_to_run
+    attr_reader :finished_tasks
 
-        case stage
-        when :disabling_pinger
-          puts '1) Application state did not change'
-          puts '2) Availability pinging could not be disabled'
+    def deploy_to_target
+      tools = ['git', 'heroku']
+      tools << 'curl' if target.requires_curl?
+      tools << 'rake' if target.requires_rake?
 
-        when :enabling_maintenance
-          puts '1) Application state did not change'
-          puts
-          puts '2) Maintenance mode could not be enabled'
-          if pinging_interaction
-            puts
-            puts '3) Availability pinging is disabled'
-            puts "* To enable: curl #{target.enable_pinger_url}"
-          end
+      # Will print out an error and halt app if a required tool is unavailable
+      assert_tools_available(tools)
 
-        when :backing_up_db
-          puts '1) Application state did not change'
-          puts
-          puts '2) Maintenance mode is enabled'
-          puts "* To disable: heroku maintenance:off --remote #{target.name}"
-          puts
-          puts '3) Database backup could not be created'
-          puts
-          if pinging_interaction
-            puts '4) Availability pinging is disabled'
-            puts "* To enable: curl #{target.enable_pinger_url}"
-          end
+      if dry_run
+        puts 'Dry run started'
 
-        when :pushing_code
-          puts '1) Application state is unknown'
-          puts
-          puts '2) Maintenance mode is enabled'
-          puts "* To disable: heroku maintenance:off --remote #{target.name}"
-          puts
-          puts '3) Application code was not pushed properly'
-          puts "* Check releases with 'heroku releases --remote #{target.name}' and rollback with " +
-                   "'heroku rollback (version) --remote #{target.name}' if needed"
-          if pinging_interaction
-            puts
-            puts '4) Availability pinging is disabled'
-            puts "* To enable: curl #{target.enable_pinger_url}"
-          end
+      elsif confirm_deploy
+        puts
+        self.start_time = Time.now
+        puts "Deploy started at #{start_time.strftime('%H:%M:%S')}"
 
-        when :migrating_db
-          puts '1) Application state is unknown'
-          puts
-          puts '2) Maintenance mode is enabled'
-          puts "* To disable: heroku maintenance:off --remote #{target.name}"
-          puts
-          puts '3) Code was pushed but database was not migrated properly'
-          puts "* Check releases with 'heroku releases --remote #{target.name}' and rollback " +
-                   "with 'heroku rollback (version) --remote #{target.name}' if needed"
-          if perform_db_backup
-            puts "* List database backups with 'heroku pgbackups --remote #{target.name}' and restore " +
-                     "with 'heroku pgbackups:restore (database name) (version) --remote #{target.name}' if needed"
-          end
-          if pinging_interaction
-            puts
-            puts '4) Availability pinging is disabled'
-            puts "* To enable: curl #{target.enable_pinger_url}"
-          end
+      else
+        print_fail 'Deploy aborted'
+        exit 1
+      end
 
-        when :restarting
-          puts '1) Application state is unknown'
-          puts
-          puts '2) Maintenance mode is enabled'
-          puts "* To disable: heroku maintenance:off --remote #{target.name}"
-          puts
-          puts '3) Database was migrated but could not restart'
-          puts "* Try to restart manually with 'heroku restart --remote #{target.name}'"
-          puts "* Check releases with 'heroku releases --remote #{target.name}' and rollback " +
-                   "with 'heroku rollback (version) --remote #{target.name}' if needed"
-          if perform_db_backup
-            puts "* List database backups with 'heroku pgbackups --remote #{target.name}' and restore " +
-                     "with 'heroku pgbackups:restore (database name) (version) --remote #{target.name}' if needed"
-          end
-          if pinging_interaction
-            puts
-            puts '4) Availability pinging is disabled'
-            puts "* To enable: curl #{target.enable_pinger_url}"
-          end
+      puts
 
-        when :enabling_pinger
-          puts '1) Application has been deployed'
-          puts
-          puts '2) Maintenance mode is enabled'
-          puts "* To disable: heroku maintenance:off --remote #{target.name}"
-          if pinging_interaction
-            puts
-            puts '3) Availability pinging could not be enabled'
-            puts "* To enable: curl #{target.enable_pinger_url}"
-          end
+      load_tasks
+      run_tasks
+    end
 
-        when :disabling_maintenance
-          puts '1) Application has been deployed'
-          puts
-          puts '2) Maintenance mode could not be disabled'
-          puts "* To disable: heroku maintenance:off --remote #{target.name}"
+    def assert_tools_available(tools)
 
-        else
-          raise 'Unknown stage'
+      def command_available?(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return true if File.executable? exe
+          end
         end
-
-        puts
+        false
       end
 
-      if message
-        puts "Deploy aborted with message: #{message}"
-      else
-        puts 'Deploy aborted'
+      all_tools_available = true
+
+      tools.each do |tool|
+        unless command_available?(tool)
+          puts "You don't have access to '#{tool}' command"
+          all_tools_available = false
+        end
       end
 
-      exit
+      exit 1 unless all_tools_available
     end
 
-    def continue?(stage)
-
-      if confirm
-        # User wants confirmations
-
-        answered = false
-        until answered
-
-          case stage
-          when :disabling_pinger
-            print 'Pinger disabled? (Yes / No) > '
-          when :enabling_maintenance
-            print 'Maintenance mode enabled? (Yes / No) > '
-          when :backing_up_db
-            print 'Database backed up? (Yes / No) > '
-          when :pushing_code
-            print 'Code pushed successfully? (Yes / No) > '
-          when :migrating_db
-            print 'Database migrated? (Yes / No) > '
-          when :restarting
-            print 'Restarted? (Yes / No) > '
-          when :enabling_pinger
-            print 'Pinger enabled? (Yes / No) > '
-          when :disabling_maintenance
-            print 'Maintenance mode disabled? (Yes / No) > '
-          else
-            raise 'Unknown stage'
-          end
-
-          answer = $stdin.gets.chomp
+    def confirm_deploy
 
-          if answer == 'Yes' || answer == 'yes'
-            answered = true
-            puts
-            yield
-          elsif answer == 'No' || answer == 'no'
-            puts
-            abort_deploy(nil, stage)
-          else
-            puts 'Unknown answer'
-            puts
-          end
+      loop do
+        if db_change
+          print "Deploy to #{target.description}? (changing DB structure) [Yes / No] > "
+        else
+          print "Deploy to #{target.description}? (not changing DB structure) [Yes / No] > "
         end
+        answer = $stdin.gets.chomp.downcase
 
-      else
-        # User does not want confirmations, continue
-        yield
-      end
-    end
+        if answer == 'yes'
+          return true
 
-    def execute_system_command(cmd)
-      if DEBUG
-        puts "Executing command: #{cmd}"
-      else
-        system(cmd)
+        elsif answer == 'no'
+          return false
+
+        else
+          puts 'Unknown answer'
+          puts
+        end
       end
     end
 
-    def check_connectivity
-      require 'open-uri'
+    def load_tasks
+      tasks_to_run << HR_Deploy::CheckNetworkTask.new(dry_run: dry_run)
+      tasks_to_run << HR_Deploy::CheckHerokuTask.new(dry_run: dry_run)
 
-      puts 'Checking Internet connection...'
+      if target.pinging_interaction?
+        tasks_to_run << HR_Deploy::DisablePingerTask.new(target: target, confirm: confirm, dry_run: dry_run)
+      end
 
-      begin
-        open('http://www.google.com')
-      rescue
-        puts 'Not connected to the Internet'
-        puts
-        abort_deploy('Not connected to the Internet')
-      else
-        puts 'Internet connection is fine'
-        puts
+      if target.maintenance_interaction?
+        tasks_to_run << HR_Deploy::EnableMaintenanceTask.new(target: target, confirm: confirm, dry_run: dry_run)
       end
-    end
 
-    def check_heroku_status
+      if target.backup_db? && db_change
+        tasks_to_run << HR_Deploy::BackupDBTask.new(target: target, confirm: confirm, dry_run: dry_run)
+      end
 
-      require 'uri'
-      require 'net/http'
-      require 'net/https'
-      require 'json'
+      if target.s3_asset_sync?
+        tasks_to_run << HR_Deploy::CleanOldAssetsTask.new(confirm: confirm, dry_run: dry_run)
+        tasks_to_run << HR_Deploy::PrecompileAssetsTask.new(confirm: confirm, dry_run: dry_run)
+      end
 
-      puts 'Checking Heroku status...'
+      tasks_to_run << HR_Deploy::PushCodeTask.new(target: target, confirm: confirm, dry_run: dry_run)
 
-      uri = URI.parse('https://status.heroku.com/api/v3/current-status')
+      if db_change
+        tasks_to_run << HR_Deploy::MigrateDBTask.new(target: target, confirm: confirm, dry_run: dry_run)
+        tasks_to_run << HR_Deploy::RestartTask.new(target: target, confirm: confirm, dry_run: dry_run)
+      end
 
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
+      if target.maintenance_interaction?
+        tasks_to_run << HR_Deploy::DisableMaintenanceTask.new(target: target, confirm: confirm, dry_run: dry_run)
+      end
 
-      request = Net::HTTP::Get.new(uri.request_uri)
+      if target.pinging_interaction?
+        tasks_to_run << HR_Deploy::EnablePingerTask.new(target: target, confirm: confirm, dry_run: dry_run)
+      end
 
-      begin
-        response = http.request(request)
+      if target.s3_asset_sync?
+        tasks_to_run << HR_Deploy::CleanNewAssetsTask.new(confirm: confirm, dry_run: dry_run)
+      end
+    end
 
-      rescue
-        puts 'Could not fetch Heroku status'
-        puts
-        abort_deploy('Could not fetch Heroku status')
+    def run_tasks
+      tasks_to_run.each do |task|
 
-      else
-        if response.code == '200'
+        task.run
 
-          status = JSON.parse(response.body)
-          status = status['status'] if status
+        if task.successful?
+          finished_tasks << task
+          puts
+        else
+          puts
+          abort_deploy(task)
+        end
+      end
 
-          if status && status['Production'] && status['Development']
+      # Successfully finished running all tasks
+      deploy_succeeded
+    end
 
-            production_ok = status['Production'] == 'green'
-            development_ok = status['Development'] == 'green'
+    def abort_deploy(failed_task)
 
-            if production_ok && development_ok
-              puts 'Heroku is operating correctly'
-              puts
-            else
-              puts 'Heroku is having problems'
-              puts
-              abort_deploy('Heroku is having problems')
-            end
-          else
+      puts '-' * 50
+      puts
+      print_app_status "* #{application_state(failed_task)}"
+      puts
+      print_fail "* #{failed_task.error}"
+      puts
 
-            puts 'Could not parse Heroku status'
-            puts
-            abort_deploy('Could not parse Heroku status')
-          end
+      # Logic to remove tasks for which it doesn't make sense to print reversal instruction
+      filter_finished_tasks
 
-        else
-          puts 'Could not fetch Heroku status'
+      finished_tasks.each do |task|
+        if task.reversal_instruction
+          puts "* #{task.reversal_instruction}"
           puts
-          abort_deploy('Could not fetch Heroku status')
         end
       end
-    end
 
-    def disable_pinging
-      puts 'Disabling availability pinger...'
-      execute_system_command("curl #{target.disable_pinger_url}")
-      puts
+      print_fail 'Deploy aborted'
+      exit 1
     end
 
-    def enable_maintenance
-      puts 'Enabling maintenance mode...'
-      execute_system_command("heroku maintenance:on --remote #{target.name}")
-      puts
-    end
+    def deploy_succeeded
+      if dry_run
+        print_deploy_successful 'Dry run complete'
+      else
+        print_deploy_successful "Deploy complete in #{(Time.now - start_time).round} seconds"
+      end
 
-    def backup_db
-      puts 'Backing up database...'
-      execute_system_command("heroku pgbackups:capture --expire --remote #{target.name}")
-      puts
+      # Execution is finished
+      exit 0
     end
 
-    def push_code
-      puts 'Pushing code...'
-      execute_system_command("git push #{target.name} master")
-      puts
+    def application_state(failed_task)
+
+      did_not_change = 'Application state did not change'
+      unknown = 'Application state is unknown'
+      deployed = 'Application has been deployed'
+
+      case failed_task
+      when HR_Deploy::CheckNetworkTask
+        did_not_change
+      when HR_Deploy::CheckHerokuTask
+        did_not_change
+      when HR_Deploy::DisablePingerTask
+        did_not_change
+      when HR_Deploy::EnableMaintenanceTask
+        did_not_change
+      when HR_Deploy::BackupDBTask
+        did_not_change
+      when HR_Deploy::CleanOldAssetsTask
+        did_not_change
+      when HR_Deploy::PrecompileAssetsTask
+        did_not_change
+      when HR_Deploy::PushCodeTask
+        did_not_change
+      when HR_Deploy::MigrateDBTask
+        unknown
+      when HR_Deploy::RestartTask
+        unknown
+      when HR_Deploy::DisableMaintenanceTask
+        deployed
+      when HR_Deploy::EnablePingerTask
+        deployed
+      when HR_Deploy::CleanNewAssetsTask
+        deployed
+      else
+        raise "Can't determine application state: failed task type is unknown"
+      end
     end
 
-    def migrate_db
-      puts 'Migrating database...'
-      execute_system_command("heroku run rake db:migrate --remote #{target.name}")
-      puts
+    def filter_finished_tasks
+
+      # Doesn't make sense to show instruction to enable pinger if it has been enabled
+      enable_pinger = finished_tasks.find { |task| task.class == HR_Deploy::EnablePingerTask }
+      disable_pinger = finished_tasks.find { |task| task.class == HR_Deploy::DisablePingerTask }
+      if enable_pinger && disable_pinger
+        finished_tasks.delete(enable_pinger)
+        finished_tasks.delete(disable_pinger)
+      end
+
+      # Doesn't make sense to show instruction to disable maintenance if it has already been disabled
+      enable_maintenance = finished_tasks.find { |task| task.class == HR_Deploy::EnableMaintenanceTask }
+      disable_maintenance = finished_tasks.find { |task| task.class == HR_Deploy::DisableMaintenanceTask }
+      if enable_maintenance && disable_maintenance
+        finished_tasks.delete(enable_maintenance)
+        finished_tasks.delete(disable_maintenance)
+      end
+
+      # Doesn't make sense to show instruction to reverse pushing code and db migration
+      # if has already pushed, migrated and restarted (deploy itself is complete)
+      if finished_tasks.find { |task| task.class == HR_Deploy::RestartTask }
+        push_code = finished_tasks.find { |task| task.class == HR_Deploy::PushCodeTask }
+        migrate_db = finished_tasks.find { |task| task.class == HR_Deploy::MigrateDBTask }
+        restart = finished_tasks.find { |task| task.class == HR_Deploy::RestartTask }
+        finished_tasks.delete(push_code)
+        finished_tasks.delete(migrate_db)
+        finished_tasks.delete(restart)
+      end
     end
 
-    def restart
-      puts 'Restarting...'
-      execute_system_command("heroku restart --remote #{target.name}")
-      puts
+    def print_fail(msg)
+      puts msg.red
     end
 
-    def enable_pinging
-      puts 'Enabling availability pinger...'
-      execute_system_command("curl #{target.enable_pinger_url}")
-      puts
+    def print_deploy_successful(msg)
+      puts msg.green
     end
 
-    def disable_maintenance
-      puts 'Disabling maintenance mode...'
-      execute_system_command("heroku maintenance:off --remote #{target.name}")
-      puts
+    def print_app_status(msg)
+      puts msg.yellow
     end
   end
 end