engineyard-serverside 1.3.7 → 1.4.0

data/lib/engineyard-serverside/configuration.rb

@@ -2,144 +2,146 @@ require 'json'
 require 'thor'
 
 module EY
-  class Deploy::Configuration
-    DEFAULT_CONFIG = Thor::CoreExt::HashWithIndifferentAccess.new({
-      "branch"       => "master",
-      "strategy"     => "Git",
-    })
-
-    attr_reader :configuration
-    alias :c :configuration
-
-    attr_writer :release_path
+  module Serverside
+    class Deploy::Configuration
+      DEFAULT_CONFIG = Thor::CoreExt::HashWithIndifferentAccess.new({
+        "branch"       => "master",
+        "strategy"     => "Git",
+      })
+
+      attr_reader :configuration
+      alias :c :configuration
+
+      attr_writer :release_path
+
+      def initialize(opts={})
+        @release_path = opts[:release_path]
+        config = JSON.parse(opts["config"] || "{}")
+        @configuration = DEFAULT_CONFIG.merge(config).merge(opts)
+      end
 
-    def initialize(opts={})
-      @release_path = opts[:release_path]
-      config = JSON.parse(opts["config"] || "{}")
-      @configuration = DEFAULT_CONFIG.merge(config).merge(opts)
-    end
+      # Delegate to the configuration objects
+      def method_missing(meth, *args, &blk)
+        c.key?(meth.to_s) ? c[meth.to_s] : super
+      end
 
-    # Delegate to the configuration objects
-    def method_missing(meth, *args, &blk)
-      c.key?(meth.to_s) ? c[meth.to_s] : super
-    end
+      def respond_to?(meth, include_private=false)
+        c.key?(meth.to_s) ? true : super
+      end
 
-    def respond_to?(meth, include_private=false)
-      c.key?(meth.to_s) ? true : super
-    end
+      def [](key)
+        if respond_to?(key.to_sym)
+          send(key.to_sym)
+        else
+          c[key]
+        end
+      end
 
-    def [](key)
-      if respond_to?(key.to_sym)
-        send(key.to_sym)
-      else
-        c[key]
+      def has_key?(key)
+        if respond_to?(key.to_sym)
+          true
+        else
+          c.has_key?(key)
+        end
       end
-    end
 
-    def has_key?(key)
-      if respond_to?(key.to_sym)
-        true
-      else
-        c.has_key?(key)
+      def to_json
+        configuration.to_json
       end
-    end
 
-    def to_json
-      configuration.to_json
-    end
+      def node
+        EY::Serverside.node
+      end
 
-    def node
-      EY.node
-    end
+      def revision
+        IO.read(File.join(latest_release, 'REVISION'))
+      end
 
-    def revision
-      IO.read(File.join(latest_release, 'REVISION'))
-    end
+      def repository_cache
+        configuration['repository_cache'] || File.join(deploy_to, "/shared/cached-copy")
+      end
 
-    def repository_cache
-      configuration['repository_cache'] || File.join(deploy_to, "/shared/cached-copy")
-    end
+      def deploy_to
+        configuration['deploy_to'] || "/data/#{app}"
+      end
 
-    def deploy_to
-      configuration['deploy_to'] || "/data/#{app}"
-    end
+      def migrate?
+        !!configuration['migrate']
+      end
 
-    def migrate?
-      !!configuration['migrate']
-    end
+      def migration_command
+        configuration['migrate'] == "migrate" ? DEFAULT_CONFIG["migrate"] : configuration['migrate']
+      end
 
-    def migration_command
-      configuration['migrate'] == "migrate" ? DEFAULT_CONFIG["migrate"] : configuration['migrate']
-    end
+      def user
+        configuration['user'] || ENV['USER']
+      end
 
-    def user
-      configuration['user'] || ENV['USER']
-    end
+      def group
+        configuration['group'] || user
+      end
 
-    def group
-      configuration['group'] || user
-    end
+      def role
+        node['instance_role']
+      end
 
-    def role
-      node['instance_role']
-    end
+      def current_role
+        current_roles.first
+      end
 
-    def current_role
-      current_roles.first
-    end
+      def copy_exclude
+        @copy_exclude ||= Array(configuration.fetch("copy_exclude", []))
+      end
 
-    def copy_exclude
-      @copy_exclude ||= Array(configuration.fetch("copy_exclude", []))
-    end
+      def environment
+        configuration['framework_env']
+      end
 
-    def environment
-      configuration['framework_env']
-    end
+      def latest_release
+        all_releases.last
+      end
 
-    def latest_release
-      all_releases.last
-    end
+      def previous_release(current=latest_release)
+        index = all_releases.index(current)
+        all_releases[index-1]
+      end
 
-    def previous_release(current=latest_release)
-      index = all_releases.index(current)
-      all_releases[index-1]
-    end
+      def oldest_release
+        all_releases.first
+      end
 
-    def oldest_release
-      all_releases.first
-    end
+      def all_releases
+        Dir.glob("#{release_dir}/*").sort
+      end
 
-    def all_releases
-      Dir.glob("#{release_dir}/*").sort
-    end
+      def binstubs_path
+        release_path + '/ey_bundler_binstubs'
+      end
 
-    def binstubs_path
-      release_path + '/ey_bundler_binstubs'
-    end
+      def framework_envs
+        "RAILS_ENV=#{environment} RACK_ENV=#{environment} MERB_ENV=#{environment}"
+      end
 
-    def framework_envs
-      "RAILS_ENV=#{environment} RACK_ENV=#{environment} MERB_ENV=#{environment}"
-    end
+      def current_path
+        File.join(deploy_to, "current")
+      end
 
-    def current_path
-      File.join(deploy_to, "current")
-    end
+      def shared_path
+        File.join(deploy_to, "shared")
+      end
 
-    def shared_path
-      File.join(deploy_to, "shared")
-    end
+      def release_dir
+        File.join(deploy_to, "releases")
+      end
 
-    def release_dir
-      File.join(deploy_to, "releases")
-    end
+      def release_path
+        @release_path ||= File.join(release_dir, Time.now.utc.strftime("%Y%m%d%H%M%S"))
+      end
 
-    def release_path
-      @release_path ||= File.join(release_dir, Time.now.utc.strftime("%Y%m%d%H%M%S"))
-    end
+      def exclusions
+        copy_exclude.map { |e| %|--exclude="#{e}"| }.join(' ')
+      end
 
-    def exclusions
-      copy_exclude.map { |e| %|--exclude="#{e}"| }.join(' ')
     end
-
   end
 end

data/lib/engineyard-serverside/deploy.rb

@@ -4,337 +4,339 @@ require 'fileutils'
 require 'json'
 
 module EY
-  class DeployBase < Task
-    include LoggedOutput
-
-    # default task
-    def deploy
-      debug "Starting deploy at #{Time.now.asctime}"
-      update_repository_cache
-      cached_deploy
-    end
+  module Serverside
+    class DeployBase < Task
+      include LoggedOutput
+
+      # default task
+      def deploy
+        debug "Starting deploy at #{Time.now.asctime}"
+        update_repository_cache
+        cached_deploy
+      end
 
-    def cached_deploy
-      debug "Deploying app from cached copy at #{Time.now.asctime}"
-      require_custom_tasks
-      push_code
+      def cached_deploy
+        debug "Deploying app from cached copy at #{Time.now.asctime}"
+        require_custom_tasks
+        push_code
+
+        info "~> Starting full deploy"
+        copy_repository_cache
+
+        with_failed_release_cleanup do
+          create_revision_file
+          run_with_callbacks(:bundle)
+          symlink_configs
+          conditionally_enable_maintenance_page
+          run_with_callbacks(:migrate)
+          callback(:before_symlink)
+          symlink
+        end
 
-      info "~> Starting full deploy"
-      copy_repository_cache
+        callback(:after_symlink)
+        run_with_callbacks(:restart)
+        disable_maintenance_page
+
+        cleanup_old_releases
+        debug "Finished deploy at #{Time.now.asctime}"
+      rescue Exception
+        debug "Finished failing to deploy at #{Time.now.asctime}"
+        puts_deploy_failure
+        raise
+      end
 
-      with_failed_release_cleanup do
-        create_revision_file
-        run_with_callbacks(:bundle)
-        symlink_configs
+      def restart_with_maintenance_page
+        require_custom_tasks
         conditionally_enable_maintenance_page
-        run_with_callbacks(:migrate)
-        callback(:before_symlink)
-        symlink
+        restart
+        disable_maintenance_page
       end
 
-      callback(:after_symlink)
-      run_with_callbacks(:restart)
-      disable_maintenance_page
+      def enable_maintenance_page
+        maintenance_page_candidates = [
+          "public/maintenance.html.custom",
+          "public/maintenance.html.tmp",
+          "public/maintenance.html",
+          "public/system/maintenance.html.default",
+        ].map do |file|
+          File.join(c.latest_release, file)
+        end
 
-      cleanup_old_releases
-      debug "Finished deploy at #{Time.now.asctime}"
-    rescue Exception
-      debug "Finished failing to deploy at #{Time.now.asctime}"
-      puts_deploy_failure
-      raise
-    end
+        # this one is guaranteed to exist
+        maintenance_page_candidates <<  File.expand_path(
+          "default_maintenance_page.html",
+          File.dirname(__FILE__)
+          )
 
-    def restart_with_maintenance_page
-      require_custom_tasks
-      conditionally_enable_maintenance_page
-      restart
-      disable_maintenance_page
-    end
+        # put in the maintenance page
+        maintenance_file = maintenance_page_candidates.detect do |file|
+          File.exists?(file)
+        end
 
-    def enable_maintenance_page
-      maintenance_page_candidates = [
-        "public/maintenance.html.custom",
-        "public/maintenance.html.tmp",
-        "public/maintenance.html",
-        "public/system/maintenance.html.default",
-      ].map do |file|
-        File.join(c.latest_release, file)
+        @maintenance_up = true
+        roles :app_master, :app, :solo do
+          maint_page_dir = File.join(c.shared_path, "system")
+          visible_maint_page = File.join(maint_page_dir, "maintenance.html")
+          run Escape.shell_command(['mkdir', '-p', maint_page_dir])
+          run Escape.shell_command(['cp', maintenance_file, visible_maint_page])
+        end
       end
 
-      # this one is guaranteed to exist
-      maintenance_page_candidates <<  File.expand_path(
-        "default_maintenance_page.html",
-        File.dirname(__FILE__)
-        )
-
-      # put in the maintenance page
-      maintenance_file = maintenance_page_candidates.detect do |file|
-        File.exists?(file)
+      def conditionally_enable_maintenance_page
+        if c.migrate? || required_downtime_stack?
+          enable_maintenance_page
+        end
       end
 
-      @maintenance_up = true
-      roles :app_master, :app, :solo do
-        maint_page_dir = File.join(c.shared_path, "system")
-        visible_maint_page = File.join(maint_page_dir, "maintenance.html")
-        run Escape.shell_command(['mkdir', '-p', maint_page_dir])
-        run Escape.shell_command(['cp', maintenance_file, visible_maint_page])
+      def required_downtime_stack?
+        %w[ nginx_mongrel glassfish ].include? c.stack
       end
-    end
 
-    def conditionally_enable_maintenance_page
-      if c.migrate? || required_downtime_stack?
-        enable_maintenance_page
+      def disable_maintenance_page
+        @maintenance_up = false
+        roles :app_master, :app, :solo do
+          run "rm -f #{File.join(c.shared_path, "system", "maintenance.html")}"
+        end
       end
-    end
-
-    def required_downtime_stack?
-      %w[ nginx_mongrel glassfish ].include? c.stack
-    end
 
-    def disable_maintenance_page
-      @maintenance_up = false
-      roles :app_master, :app, :solo do
-        run "rm -f #{File.join(c.shared_path, "system", "maintenance.html")}"
+      def run_with_callbacks(task)
+        callback("before_#{task}")
+        send(task)
+        callback("after_#{task}")
       end
-    end
 
-    def run_with_callbacks(task)
-      callback("before_#{task}")
-      send(task)
-      callback("after_#{task}")
-    end
+      # task
+      def push_code
+        info "~> Pushing code to all servers"
+        barrier *(EY::Serverside::Server.all.map do |server|
+          need_later { server.sync_directory(config.repository_cache) }
+        end)
+      end
 
-    # task
-    def push_code
-      info "~> Pushing code to all servers"
-      barrier *(EY::Server.all.map do |server|
-        need_later { server.sync_directory(config.repository_cache) }
-      end)
-    end
+      # task
+      def restart
+        @restart_failed = true
+        info "~> Restarting app servers"
+        roles :app_master, :app, :solo do
+          run(restart_command)
+        end
+        @restart_failed = false
+      end
 
-    # task
-    def restart
-      @restart_failed = true
-      info "~> Restarting app servers"
-      roles :app_master, :app, :solo do
-        run(restart_command)
+      def restart_command
+        "/engineyard/bin/app_#{c.app} deploy"
       end
-      @restart_failed = false
-    end
 
-    def restart_command
-      "/engineyard/bin/app_#{c.app} deploy"
-    end
+      # task
+      def bundle
+        if File.exist?("#{c.release_path}/Gemfile")
+          info "~> Gemfile detected, bundling gems"
+          lockfile = File.join(c.release_path, "Gemfile.lock")
 
-    # task
-    def bundle
-      if File.exist?("#{c.release_path}/Gemfile")
-        info "~> Gemfile detected, bundling gems"
-        lockfile = File.join(c.release_path, "Gemfile.lock")
+          bundler_installer = if File.exist?(lockfile)
+                                get_bundler_installer(lockfile)
+                              else
+                                warn_about_missing_lockfile
+                                bundler_09_installer(default_09_bundler)
+                              end
 
-        bundler_installer = if File.exist?(lockfile)
-                              get_bundler_installer(lockfile)
-                            else
-                              warn_about_missing_lockfile
-                              bundler_09_installer(default_09_bundler)
-                            end
+          sudo "#{$0} _#{EY::Serverside::VERSION}_ install_bundler #{bundler_installer.version}"
 
-        sudo "#{$0} _#{VERSION}_ install_bundler #{bundler_installer.version}"
+          run "cd #{c.release_path} && bundle _#{bundler_installer.version}_ install #{bundler_installer.options}"
+        end
+      end
 
-        run "cd #{c.release_path} && bundle _#{bundler_installer.version}_ install #{bundler_installer.options}"
+      # task
+      def cleanup_old_releases
+        @cleanup_failed = true
+        info "~> Cleaning up old releases"
+        sudo "ls #{c.release_dir} | head -n -3 | xargs -I{} rm -rf #{c.release_dir}/{}"
+        @cleanup_failed = false
       end
-    end
 
-    # task
-    def cleanup_old_releases
-      @cleanup_failed = true
-      info "~> Cleaning up old releases"
-      sudo "ls #{c.release_dir} | head -n -3 | xargs -I{} rm -rf #{c.release_dir}/{}"
-      @cleanup_failed = false
-    end
+      # task
+      def rollback
+        if c.all_releases.size > 1
+          rolled_back_release = c.latest_release
+          c.release_path = c.previous_release(rolled_back_release)
 
-    # task
-    def rollback
-      if c.all_releases.size > 1
-        rolled_back_release = c.latest_release
-        c.release_path = c.previous_release(rolled_back_release)
-
-        revision = File.read(File.join(c.release_path, 'REVISION')).strip
-        info "~> Rolling back to previous release: #{short_log_message(revision)}"
-
-        run_with_callbacks(:symlink)
-        sudo "rm -rf #{rolled_back_release}"
-        bundle
-        info "~> Restarting with previous release"
-        with_maintenance_page { run_with_callbacks(:restart) }
-      else
-        info "~> Already at oldest release, nothing to roll back to"
-        exit(1)
-      end
-    end
+          revision = File.read(File.join(c.release_path, 'REVISION')).strip
+          info "~> Rolling back to previous release: #{short_log_message(revision)}"
 
-    # task
-    def migrate
-      return unless c.migrate?
-      @migrations_reached = true
-      roles :app_master, :solo do
-        cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} #{c.migration_command}"
-        info "~> Migrating: #{cmd}"
-        run(cmd)
+          run_with_callbacks(:symlink)
+          sudo "rm -rf #{rolled_back_release}"
+          bundle
+          info "~> Restarting with previous release"
+          with_maintenance_page { run_with_callbacks(:restart) }
+        else
+          info "~> Already at oldest release, nothing to roll back to"
+          exit(1)
+        end
       end
-    end
 
-    # task
-    def copy_repository_cache
-      info "~> Copying to #{c.release_path}"
-      run("mkdir -p #{c.release_path} && rsync -aq #{c.exclusions} #{c.repository_cache}/ #{c.release_path}")
+      # task
+      def migrate
+        return unless c.migrate?
+        @migrations_reached = true
+        roles :app_master, :solo do
+          cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} #{c.migration_command}"
+          info "~> Migrating: #{cmd}"
+          run(cmd)
+        end
+      end
 
-      info "~> Ensuring proper ownership"
-      sudo("chown -R #{c.user}:#{c.group} #{c.deploy_to}")
-    end
+      # task
+      def copy_repository_cache
+        info "~> Copying to #{c.release_path}"
+        run("mkdir -p #{c.release_path} && rsync -aq #{c.exclusions} #{c.repository_cache}/ #{c.release_path}")
 
-    def create_revision_file
-      run create_revision_file_command
-    end
+        info "~> Ensuring proper ownership"
+        sudo("chown -R #{c.user}:#{c.group} #{c.deploy_to}")
+      end
 
-    def symlink_configs(release_to_link=c.release_path)
-      info "~> Symlinking configs"
-      [ "chmod -R g+w #{release_to_link}",
-        "rm -rf #{release_to_link}/log #{release_to_link}/public/system #{release_to_link}/tmp/pids",
-        "mkdir -p #{release_to_link}/tmp",
-        "ln -nfs #{c.shared_path}/log #{release_to_link}/log",
-        "mkdir -p #{release_to_link}/public",
-        "mkdir -p #{release_to_link}/config",
-        "ln -nfs #{c.shared_path}/system #{release_to_link}/public/system",
-        "ln -nfs #{c.shared_path}/pids #{release_to_link}/tmp/pids",
-        "find #{c.shared_path}/config -type f -exec ln -s {} #{release_to_link}/config \\;",
-        "ln -nfs #{c.shared_path}/config/database.yml #{release_to_link}/config/database.yml",
-        "ln -nfs #{c.shared_path}/config/mongrel_cluster.yml #{release_to_link}/config/mongrel_cluster.yml",
-      ].each do |cmd|
-        run cmd
+      def create_revision_file
+        run create_revision_file_command
       end
 
-      sudo "chown -R #{c.user}:#{c.group} #{release_to_link}"
-      run "if [ -f \"#{c.shared_path}/config/newrelic.yml\" ]; then ln -nfs #{c.shared_path}/config/newrelic.yml #{release_to_link}/config/newrelic.yml; fi"
-    end
+      def symlink_configs(release_to_link=c.release_path)
+        info "~> Symlinking configs"
+        [ "chmod -R g+w #{release_to_link}",
+          "rm -rf #{release_to_link}/log #{release_to_link}/public/system #{release_to_link}/tmp/pids",
+          "mkdir -p #{release_to_link}/tmp",
+          "ln -nfs #{c.shared_path}/log #{release_to_link}/log",
+          "mkdir -p #{release_to_link}/public",
+          "mkdir -p #{release_to_link}/config",
+          "ln -nfs #{c.shared_path}/system #{release_to_link}/public/system",
+          "ln -nfs #{c.shared_path}/pids #{release_to_link}/tmp/pids",
+          "find #{c.shared_path}/config -type f -exec ln -s {} #{release_to_link}/config \\;",
+          "ln -nfs #{c.shared_path}/config/database.yml #{release_to_link}/config/database.yml",
+          "ln -nfs #{c.shared_path}/config/mongrel_cluster.yml #{release_to_link}/config/mongrel_cluster.yml",
+        ].each do |cmd|
+          run cmd
+        end
 
-    # task
-    def symlink(release_to_link=c.release_path)
-      info "~> Symlinking code"
-      run "rm -f #{c.current_path} && ln -nfs #{release_to_link} #{c.current_path} && chown -R #{c.user}:#{c.group} #{c.current_path}"
-      @symlink_changed = true
-    rescue Exception
-      sudo "rm -f #{c.current_path} && ln -nfs #{c.previous_release(release_to_link)} #{c.current_path} && chown -R #{c.user}:#{c.group} #{c.current_path}"
-      @symlink_changed = false
-      raise
-    end
+        sudo "chown -R #{c.user}:#{c.group} #{release_to_link}"
+        run "if [ -f \"#{c.shared_path}/config/newrelic.yml\" ]; then ln -nfs #{c.shared_path}/config/newrelic.yml #{release_to_link}/config/newrelic.yml; fi"
+      end
+
+      # task
+      def symlink(release_to_link=c.release_path)
+        info "~> Symlinking code"
+        run "rm -f #{c.current_path} && ln -nfs #{release_to_link} #{c.current_path} && chown -R #{c.user}:#{c.group} #{c.current_path}"
+        @symlink_changed = true
+      rescue Exception
+        sudo "rm -f #{c.current_path} && ln -nfs #{c.previous_release(release_to_link)} #{c.current_path} && chown -R #{c.user}:#{c.group} #{c.current_path}"
+        @symlink_changed = false
+        raise
+      end
 
-    def callback(what)
-      @callbacks_reached ||= true
-      if File.exist?("#{c.release_path}/deploy/#{what}.rb")
-        run Escape.shell_command(base_callback_command_for(what)) do |server, cmd|
-          per_instance_args = [
-            '--current-roles', server.roles.join(' '),
-            '--config', c.to_json,
-          ]
-          per_instance_args << '--current-name' << server.name.to_s if server.name
-          cmd << " " << Escape.shell_command(per_instance_args)
+      def callback(what)
+        @callbacks_reached ||= true
+        if File.exist?("#{c.release_path}/deploy/#{what}.rb")
+          run Escape.shell_command(base_callback_command_for(what)) do |server, cmd|
+            per_instance_args = [
+              '--current-roles', server.roles.join(' '),
+              '--config', c.to_json,
+            ]
+            per_instance_args << '--current-name' << server.name.to_s if server.name
+            cmd << " " << Escape.shell_command(per_instance_args)
+          end
         end
       end
-    end
 
-    protected
+      protected
 
-    def base_callback_command_for(what)
-      [$0, version_specifier, 'hook', what.to_s,
-        '--app', config.app.to_s,
-        '--release-path', config.release_path.to_s,
-        '--framework-env', c.environment.to_s,
-      ].compact
-    end
+      def base_callback_command_for(what)
+        [$0, version_specifier, 'hook', what.to_s,
+          '--app', config.app.to_s,
+          '--release-path', config.release_path.to_s,
+          '--framework-env', c.environment.to_s,
+        ].compact
+      end
 
-    def version_specifier
-      "_#{VERSION}_"
-    end
+      def version_specifier
+        "_#{EY::Serverside::VERSION}_"
+      end
 
 
-    def puts_deploy_failure
-      if @cleanup_failed
-        info "~> [Relax] Your site is running new code, but cleaning up old deploys failed"
-      elsif @maintenance_up
-        info "~> [Attention] Maintenance page still up, consider the following before removing:"
-        info " * any deploy hooks ran, be careful if they were destructive" if @callbacks_reached
-        info " * any migrations ran, be careful if they were destructive" if @migrations_reached
-        if @symlink_changed
-          info " * your new code is symlinked as current"
+      def puts_deploy_failure
+        if @cleanup_failed
+          info "~> [Relax] Your site is running new code, but cleaning up old deploys failed"
+        elsif @maintenance_up
+          info "~> [Attention] Maintenance page still up, consider the following before removing:"
+          info " * any deploy hooks ran, be careful if they were destructive" if @callbacks_reached
+          info " * any migrations ran, be careful if they were destructive" if @migrations_reached
+          if @symlink_changed
+            info " * your new code is symlinked as current"
+          else
+            info " * your old code is still symlinked as current"
+          end
+          info " * application servers failed to restart" if @restart_failed
         else
-          info " * your old code is still symlinked as current"
+          info "~> [Relax] Your site is still running old code and nothing destructive could have occurred"
         end
-        info " * application servers failed to restart" if @restart_failed
-      else
-        info "~> [Relax] Your site is still running old code and nothing destructive could have occurred"
       end
-    end
 
-    def with_maintenance_page
-      conditionally_enable_maintenance_page
-      yield if block_given?
-      disable_maintenance_page
-    end
+      def with_maintenance_page
+        conditionally_enable_maintenance_page
+        yield if block_given?
+        disable_maintenance_page
+      end
 
-    def with_failed_release_cleanup
-      yield
-    rescue Exception
-      sudo "rm -rf #{c.release_path}"
-      raise
-    end
+      def with_failed_release_cleanup
+        yield
+      rescue Exception
+        sudo "rm -rf #{c.release_path}"
+        raise
+      end
 
-    def warn_about_missing_lockfile
-      info "!>"
-      info "!> WARNING: Gemfile.lock is missing!"
-      info "!> You can get different gems in production than what you tested with."
-      info "!> You can get different gems on every deployment even if your Gemfile hasn't changed."
-      info "!> Deploying may take a long time."
-      info "!>"
-      info "!> Fix this by running \"git add Gemfile.lock; git commit\" and deploying again."
-      info "!> If you don't have a Gemfile.lock, run \"bundle lock\" to create one."
-      info "!>"
-      info "!> This deployment will use bundler #{default_09_bundler} to run 'bundle install'."
-      info "!>"
-    end
+      def warn_about_missing_lockfile
+        info "!>"
+        info "!> WARNING: Gemfile.lock is missing!"
+        info "!> You can get different gems in production than what you tested with."
+        info "!> You can get different gems on every deployment even if your Gemfile hasn't changed."
+        info "!> Deploying may take a long time."
+        info "!>"
+        info "!> Fix this by running \"git add Gemfile.lock; git commit\" and deploying again."
+        info "!> If you don't have a Gemfile.lock, run \"bundle lock\" to create one."
+        info "!>"
+        info "!> This deployment will use bundler #{default_09_bundler} to run 'bundle install'."
+        info "!>"
+      end
 
-    def get_bundler_installer(lockfile)
-      parser = LockfileParser.new(File.read(lockfile))
-      case parser.lockfile_version
-      when :bundler09
-        bundler_09_installer(parser.bundler_version || default_09_bundler)
-      when :bundler10
-        bundler_10_installer(parser.bundler_version || default_10_bundler)
-      else
-        raise "Unknown lockfile version #{parser.lockfile_version}"
+      def get_bundler_installer(lockfile)
+        parser = LockfileParser.new(File.read(lockfile))
+        case parser.lockfile_version
+        when :bundler09
+          bundler_09_installer(parser.bundler_version || default_09_bundler)
+        when :bundler10
+          bundler_10_installer(parser.bundler_version || default_10_bundler)
+        else
+          raise "Unknown lockfile version #{parser.lockfile_version}"
+        end
       end
-    end
-    public :get_bundler_installer
+      public :get_bundler_installer
 
-    def bundler_09_installer(version)
-      BundleInstaller.new(version, '--without=development --without=test')
-    end
+      def bundler_09_installer(version)
+        BundleInstaller.new(version, '--without=development --without=test')
+      end
 
-    def bundler_10_installer(version)
-      BundleInstaller.new(version,
-        "--deployment --path #{c.shared_path}/bundled_gems --binstubs #{c.binstubs_path} --without development test")
-    end
+      def bundler_10_installer(version)
+        BundleInstaller.new(version,
+          "--deployment --path #{c.shared_path}/bundled_gems --binstubs #{c.binstubs_path} --without development test")
+      end
 
-    def default_09_bundler() "0.9.26" end
-    def default_10_bundler() "1.0.0"  end
+      def default_09_bundler() "0.9.26" end
+      def default_10_bundler() "1.0.0"  end
 
-  end   # DeployBase
+    end   # DeployBase
 
-  class Deploy < DeployBase
-    def self.new(config)
-      # include the correct fetch strategy
-      include EY::Strategies.const_get(config.strategy)::Helpers
-      super
+    class Deploy < DeployBase
+      def self.new(config)
+        # include the correct fetch strategy
+        include EY::Serverside::Strategies.const_get(config.strategy)::Helpers
+        super
+      end
     end
 
   end