harrison 0.2.0 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,26 @@
+0.3.0
+-------------------
+- BREAKING: Definition of "deploy" task has significantly changed. Deploys
+  are now comprised of 1 or more phases and each phase must complete
+  successfully on all hosts before proceeding to the next phase. If an
+  error is encountered, Harrison will attempt to unwind any changes made
+  by previously completed phases by invoking the code block supplied to
+  each phase's "on_fail" method. There are several built-in phases to
+  perform common deployment related tasks. See the README for more
+  information.
+
+- BREAKING: Commands executed with remote_exec() inside the "run" block of
+  the "package" task will now execute in your commit working directory, so
+  you no longer need to prefix commands with "cd #{h.commit}". You will
+  need to update existing Harrisonfile "package" run blocks to reflect the
+  change of execution context.
+
+- Allow multiple users to execute the "package" task for the same project
+  simultaneously.
+
+- Added "rollback" command which will create a new deploy pointing to the
+  previously active release.
+
 0.2.0
 -------------------
 - Implemented the ability to purge old releases after a successful deploy.

data/README.md

@@ -49,20 +49,73 @@ Harrison.package do |h|
 end
 
 Harrison.deploy do |h|
-  h.hosts = [ 'util-server-01.example.com', 'app-server-01.example.com', 'app-server-02.example.com' ]
   h.user = 'jesse'
   h.base_dir = '/opt'
 
-  # Run block will be invoked once for each host after new code is in place.
-  h.run do |h|
-    # You can interrogate h.host to see what host you are currently running on.
-    if h.host =~ /util/
-      # Do something on the util box.
-    else
-      puts "Reloading Unicorn on #{h.host}..."
-      h.remote_exec("sudo -- /etc/init.d/unicorn_#{h.project} reload")
+  h.hosts = [ 'util-server-01.example.com', 'app-server-01.example.com', 'app-server-02.example.com' ]
+
+  # How many deploys to keep around after a successful new deploy.
+  h.keep = 5
+
+  # Built in phases:
+  #  - :upload    Uploads your artifact to the host.
+  #  - :extract   Extracts your artifact into a release folder.
+  #  - :link      Creates a new deploy symlink pointed to the new release.
+  #  - :cleanup   Removes deploys older than the --keep option, if set.
+  #
+  # You can override these phases by adding a phase with the same name below.
+  #
+  # You will probably want to add one or more phases to actually do restart
+  # your application in an appropriate way.
+  #
+  # The built in "rollback" action will run your configured phases except
+  # that it will not run any phases named "upload", "extract", or "cleanup".
+  # Also, h.rollback can be inspected to distinguish a "rollback" action from
+  # a normal "deploy" action.
+
+  h.add_phase :migrate do |phase|
+    # Only run this phase on util boxes.
+    phase.add_condition { |h| h.host =~ /util/ }
+
+    phase.on_run do |h|
+      # Make the "current" symlink point to the new deploy.
+      h.update_current_symlink
+
+      h.remote_exec(%Q(bash -l -c "bundle exec rake db:migrate"))
+    end
+
+    phase.on_fail do |h|
+      # Make the "current" symlink point back to the previously active deploy.
+      h.revert_current_symlink
+
+      h.remote_exec(%Q(bash -l -c "bundle exec rake db:migrate"))
+    end
+  end
+
+  h.add_phase :restart do |phase|
+    # Only run this phase on non-util boxes.
+    phase.add_condition { |h| h.host !~ /util/ }
+
+    phase.on_run do |h|
+      # Make the "current" symlink point to the new deploy.
+      h.update_current_symlink
+
+      h.remote_exec("touch #{h.current_symlink}/restart.txt")
+    end
+
+    phase.on_fail do |h|
+      # Make the "current" symlink point back to the previously active deploy.
+      h.revert_current_symlink
+
+      h.remote_exec("touch #{h.current_symlink}/restart.txt")
     end
   end
+
+  # Define what phases to run and in what order on each host. Each
+  # phase will need to complete on every host before moving on to the
+  # next phase. If a phase fails on a host, all completed phases/hosts
+  # will have the "on_fail" block executed in reverse order.
+  h.phases = [ :upload, :extract, :link, :migrate, :restart, :cleanup ]
 end
 ```
 

data/harrison.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
   spec.add_development_dependency "debugger" if RUBY_VERSION < "2.0.0"
   spec.add_development_dependency "byebug" if RUBY_VERSION >= "2.0.0"
   spec.add_development_dependency "sourcify"

data/lib/harrison.rb

@@ -5,11 +5,16 @@ require "harrison/config"
 require "harrison/base"
 require "harrison/package"
 require "harrison/deploy"
+require "harrison/deploy/phase"
 
 module Harrison
 
   def self.invoke(args)
     @@args = args.freeze
+    @@task_runners = {
+      package: nil,
+      deploy: nil,
+    }
 
     abort("No command given. Run with --help for valid commands and options.") if @@args.empty?
 
@@ -17,12 +22,10 @@ module Harrison
     Harrison::Base.new.parse(@@args.dup) and exit(0) if @@args[0] == '--help'
 
     # Find Harrisonfile.
-    hf = find_harrisonfile
-    abort("ERROR: Could not find a Harrisonfile in this directory or any ancestor.") if hf.nil?
+    hf = find_harrisonfile || abort("ERROR: Could not find a Harrisonfile in this directory or any ancestor.")
 
     # Find the class to handle command.
-    @@runner = find_runner(@@args[0])
-    abort("ERROR: Unrecognized command \"#{@@args[0]}\".") unless @@runner
+    @@runner = find_runner(@@args[0]) || abort("ERROR: Unrecognized command \"#{@@args[0]}\".")
 
     # Eval the Harrisonfile.
     eval_script(hf)
@@ -30,6 +33,8 @@ module Harrison
     # Invoke command and cleanup afterwards.
     begin
       @@runner.call.run
+    rescue => e
+      raise e
     ensure
       @@runner.call.close
     end
@@ -46,21 +51,21 @@ module Harrison
   end
 
   def self.package(opts={})
-    @@packager ||= Harrison::Package.new(opts)
+    @@task_runners[:package] ||= Harrison::Package.new(opts)
 
     # Parse options if this is the target command.
-    @@packager.parse(@@args.dup) if @@runner && @@runner.call == @@packager
+    @@task_runners[:package].parse(@@args.dup) if @@runner && @@runner.call == @@task_runners[:package]
 
-    yield @@packager
+    yield @@task_runners[:package]
   end
 
   def self.deploy(opts={})
-    @@deployer ||= Harrison::Deploy.new(opts)
+    @@task_runners[:deploy] ||= Harrison::Deploy.new(opts)
 
     # Parse options if this is the target command.
-    @@deployer.parse(@@args.dup) if @@runner && @@runner.call == @@deployer
+    @@task_runners[:deploy].parse(@@args.dup) if @@runner && @@runner.call == @@task_runners[:deploy]
 
-    yield @@deployer
+    yield @@task_runners[:deploy]
   end
 
 
@@ -83,9 +88,8 @@ module Harrison
   end
 
   def self.find_runner(command)
-    case command.downcase
-      when 'package' then lambda { @@packager if self.class_variable_defined?(:@@packager) }
-      when 'deploy' then lambda { @@deployer if self.class_variable_defined?(:@@deployer) }
-    end
+    command = 'deploy' if command == 'rollback'
+
+    lambda { @@task_runners[command.to_sym] } if @@task_runners.has_key?(command.to_sym)
   end
 end

data/lib/harrison/base.rb

@@ -34,14 +34,22 @@ module Harrison
 
     def exec(cmd)
       result = `#{cmd}`
-      abort("ERROR: Unable to execute local command: \"#{cmd}\"") if !$?.success? || result.nil?
-      result.strip
+
+      if ($?.success? && result)
+        result.strip
+      else
+        throw :failure, true
+      end
     end
 
     def remote_exec(cmd)
       result = ssh.exec(cmd)
-      abort("ERROR: Unable to execute remote command: \"#{cmd}\"") if result.nil?
-      result.strip
+
+      if result
+        result.strip
+      else
+        throw :failure, true
+      end
     end
 
     def parse(args)
@@ -97,7 +105,7 @@ module Harrison
     end
 
     def ensure_remote_dir(dir, with_ssh = nil)
-      with_ssh = ssh if with_ssh.nil?
+      with_ssh ||= ssh
       host = with_ssh.host
 
       @_ensured_remote ||= {}

data/lib/harrison/deploy.rb

@@ -5,6 +5,11 @@ module Harrison
     attr_accessor :release_dir
     attr_accessor :deploy_link
 
+    attr_accessor :rollback
+    attr_accessor :phases
+
+    alias :invoke_user_block :run
+
     def initialize(opts={})
       # Config helpers for Harrisonfile.
       self.class.option_helper(:hosts)
@@ -21,6 +26,8 @@ module Harrison
       ]
 
       super(arg_opts, opts)
+
+      self.add_default_phases
     end
 
     def parse(args)
@@ -29,77 +36,120 @@ module Harrison
       # Preserve argv hosts if it's been passed.
       @_argv_hosts = self.hosts.dup if self.hosts
 
-      # Make sure they passed an artifact.
-      self.artifact = args[1] || abort("ERROR: You must specify the artifact to be deployed as an argument to this command.")
+      self.rollback = args[0] == 'rollback'
+
+      unless self.rollback
+        # Make sure they passed an artifact.
+        self.artifact = args[1] || abort("ERROR: You must specify the artifact to be deployed as an argument to this command.")
+      end
+    end
+
+    def add_phase(name, &block)
+      @_phases ||= Hash.new
+
+      @_phases[name] = Harrison::Deploy::Phase.new(name, &block)
     end
 
     def remote_exec(cmd)
       super("cd #{remote_project_dir} && #{cmd}")
     end
 
-    def run(&block)
-      return super if block_given?
+    def current_symlink
+      "#{self.remote_project_dir}/current"
+    end
+
+    def update_current_symlink
+      @_old_current = self.remote_exec("if [ -L #{current_symlink} ]; then readlink -vn #{current_symlink}; fi")
+      @_old_current = nil if @_old_current.empty?
+
+      # Symlink current to new deploy.
+      self.remote_exec("ln -sfn #{self.deploy_link} #{self.current_symlink}")
+    end
+
+    def revert_current_symlink
+      # Restore current symlink to previous if set.
+      if @_old_current
+        self.remote_exec("ln -sfn #{@_old_current} #{self.current_symlink}")
+      end
+    end
 
+    def run
       # Override Harrisonfile hosts if it was passed on argv.
       self.hosts = @_argv_hosts if @_argv_hosts
 
+      # Require at least one host.
       if !self.hosts || self.hosts.empty?
-        abort("ERROR: You must specify one or more hosts to deploy to, either in your Harrisonfile or via --hosts.")
+        abort("ERROR: You must specify one or more hosts to deploy/rollback on, either in your Harrisonfile or via --hosts.")
       end
 
+      # Default to just built in deployment phases.
+      self.phases ||= [ :upload, :extract, :link, :cleanup ]
+
       # Default base_dir.
       self.base_dir ||= '/opt'
 
-      puts "Deploying #{artifact} for \"#{project}\" onto #{hosts.size} hosts..."
+      if self.rollback
+        puts "Rolling back \"#{project}\" to previously deployed release on #{hosts.size} hosts...\n\n"
 
-      self.release_dir = "#{remote_project_dir}/releases/" + File.basename(artifact, '.tar.gz')
-      self.deploy_link = "#{remote_project_dir}/deploys/" + Time.new.utc.strftime('%Y-%m-%d_%H%M%S')
+        # Find the prior deploy on the first host.
+        self.host = hosts[0]
+        last_deploy = self.deploys.sort.reverse[1] || abort("ERROR: No previous deploy to rollback to.")
+        self.release_dir = remote_exec("cd deploys && readlink -vn #{last_deploy}")
+
+        # No need to upload or extract for rollback.
+        self.phases.delete(:upload)
+        self.phases.delete(:extract)
 
-      hosts.each do |h|
-        self.host = h
+        # Don't cleanup old deploys either.
+        self.phases.delete(:cleanup)
+      else
+        puts "Deploying #{artifact} for \"#{project}\" onto #{hosts.size} hosts...\n\n"
+        self.release_dir = "#{remote_project_dir}/releases/" + File.basename(artifact, '.tar.gz')
+      end
 
-        ensure_remote_dir("#{remote_project_dir}/deploys", self.ssh)
-        ensure_remote_dir("#{remote_project_dir}/releases", self.ssh)
+      self.deploy_link = "#{remote_project_dir}/deploys/" + Time.new.utc.strftime('%Y-%m-%d_%H%M%S')
 
-        # Make folder for release or bail if it already exists.
-        remote_exec("mkdir #{release_dir}")
+      progress_stack = []
 
-        if match = remote_regex.match(artifact)
-          # Copy artifact to host from remote source.
-          src_user, src_host, src_path = match.captures
-          src_user ||= self.user
+      failed = catch(:failure) do
+        self.phases.each do |phase_name|
+          phase = @_phases[phase_name] || abort("ERROR: Could not resolve \"#{phase_name}\" as a deployment phase.")
 
-          remote_exec("scp #{src_user}@#{src_host}:#{src_path} #{remote_project_dir}/releases/")
-        else
-          # Upload artifact to host.
-          upload(artifact, "#{remote_project_dir}/releases/")
-        end
+          self.hosts.each do |host|
+            self.host = host
 
-        # Unpack.
-        remote_exec("cd #{release_dir} && tar -xzf ../#{File.basename(artifact)}")
+            phase._run(self)
 
-        # Clean up artifact.
-        remote_exec("rm -f #{remote_project_dir}/releases/#{File.basename(artifact)}")
+            # Track what phases we have completed on which hosts, in a stack.
+            progress_stack << { host: host, phase: phase_name }
+          end
+        end
 
-        # Symlink a new deploy to this release.
-        remote_exec("ln -s #{release_dir} #{deploy_link}")
+        # We want "failed" to be false if nothing was caught.
+        false
+      end
 
-        # Symlink current to new deploy.
-        remote_exec("ln -sfn #{deploy_link} #{remote_project_dir}/current")
+      if failed
+        print "\n"
 
-        # Run user supplied deploy code to restart server or whatever.
-        super
+        progress_stack.reverse.each do |progress|
+          self.host = progress[:host]
+          phase = @_phases[progress[:phase]]
 
-        # Cleanup old releases if a keep value is set.
-        if (self.keep)
-          cleanup_deploys(self.keep)
-          cleanup_releases
+          # Don't let failures interrupt the rest of the process.
+          catch(:failure) do
+            phase._fail(self)
+          end
         end
 
-        close(self.host)
+        abort "\nDeployment failed, previously completed deployment actions have been reverted."
+      else
+        if self.rollback
+          puts "\nSucessfully rolled back #{project} on #{hosts.join(', ')}."
+        else
+          puts "\nSucessfully deployed #{artifact} to #{hosts.join(', ')}."
+        end
       end
-
-      puts "Sucessfully deployed #{artifact} to #{hosts.join(', ')}."
     end
 
     def cleanup_deploys(limit)
@@ -107,7 +157,7 @@ module Harrison
       purge_deploys = self.deploys.sort.reverse.slice(limit..-1) || []
 
       if purge_deploys.size > 0
-        puts "Purging #{purge_deploys.size} old deploys on #{self.host}, keeping #{limit}..."
+        puts "[#{self.host}]   Purging #{purge_deploys.size} old deploys. (Keeping #{limit}...)"
 
         purge_deploys.each do |stale_deploy|
           remote_exec("cd deploys && rm -f #{stale_deploy}")
@@ -138,6 +188,74 @@ module Harrison
 
     protected
 
+    def add_default_phases
+      self.add_phase :upload do |phase|
+        phase.on_run do |h|
+          h.ensure_remote_dir("#{h.remote_project_dir}/deploys")
+          h.ensure_remote_dir("#{h.remote_project_dir}/releases")
+
+          # Remove if it already exists.
+          # TODO: if --force only?
+          h.remote_exec("rm -f #{h.remote_project_dir}/releases/#{File.basename(h.artifact)}")
+
+          if match = h.remote_regex.match(h.artifact)
+            # Copy artifact to host from remote source.
+            src_user, src_host, src_path = match.captures
+            src_user ||= h.user
+
+            h.remote_exec("scp #{src_user}@#{src_host}:#{src_path} #{h.remote_project_dir}/releases/")
+          else
+            # Upload artifact to host.
+            h.upload(h.artifact, "#{h.remote_project_dir}/releases/")
+          end
+        end
+
+        phase.on_fail do |h|
+          # Remove staged artifact.
+          h.remote_exec("rm -f #{h.remote_project_dir}/releases/#{File.basename(h.artifact)}")
+        end
+      end
+
+      self.add_phase :extract do |phase|
+        phase.on_run do |h|
+          # Make folder for release or bail if it already exists.
+          h.remote_exec("mkdir #{h.release_dir}")
+
+          # Unpack.
+          h.remote_exec("cd #{h.release_dir} && tar -xzf ../#{File.basename(h.artifact)}")
+
+          # Clean up artifact.
+          h.remote_exec("rm -f #{h.remote_project_dir}/releases/#{File.basename(h.artifact)}")
+        end
+
+        phase.on_fail do |h|
+          # Remove release.
+          h.remote_exec("rm -rf #{h.release_dir}")
+        end
+      end
+
+      self.add_phase :link do |phase|
+        phase.on_run do |h|
+          # Symlink new deploy to this release.
+          h.remote_exec("ln -s #{h.release_dir} #{h.deploy_link}")
+        end
+
+        phase.on_fail do |h|
+          # Remove broken deploy.
+          h.remote_exec("rm -f #{h.deploy_link}")
+        end
+      end
+
+      self.add_phase :cleanup do |phase|
+        phase.on_run do |h|
+          if (h.keep)
+            h.cleanup_deploys(h.keep)
+            h.cleanup_releases
+          end
+        end
+      end
+    end
+
     def ssh
       @_conns ||= {}
       @_conns[self.host] ||= Harrison::SSH.new(host: self.host, user: @options[:user], proxy: self.deploy_via)
@@ -147,7 +265,7 @@ module Harrison
       "#{base_dir}/#{project}"
     end
 
-    # Return a sorted list of deploys, unsorted.
+    # Return a list of deploys, unsorted.
     def deploys
       remote_exec("cd deploys && ls -1").split("\n")
     end