chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/monkey_patches/net_http.rb

@@ -0,0 +1,22 @@
+
+# Module gets mixed in to Net::HTTP exception classes so we can attach our
+# RESTRequest object to them and get the request parameters back out later.
+module ChefNetHTTPExceptionExtensions
+  attr_accessor :chef_rest_request
+end
+
+require 'net/http'
+module Net
+  class HTTPError
+    include ChefNetHTTPExceptionExtensions
+  end
+  class HTTPRetriableError
+    include ChefNetHTTPExceptionExtensions
+  end
+  class HTTPServerException
+    include ChefNetHTTPExceptionExtensions
+  end
+  class HTTPFatalError
+    include ChefNetHTTPExceptionExtensions
+  end
+end

data/lib/chef/node.rb

@@ -435,7 +435,7 @@ class Chef
     # invalidated only when run_list is mutated?
     def expand!(data_source = 'server')
       expansion = run_list.expand(chef_environment, data_source)
-      raise Chef::Exceptions::MissingRole if expansion.errors?
+      raise Chef::Exceptions::MissingRole, expansion if expansion.errors?
 
       self.tags # make sure they're defined
 
@@ -624,7 +624,11 @@ class Chef
       # Try PUT. If the node doesn't yet exist, PUT will return 404,
       # so then POST to create.
       begin
-        chef_server_rest.put_rest("nodes/#{name}", self)
+        if Chef::Config[:why_run]
+          Chef::Log.warn("In whyrun mode, so NOT performing node save.")
+        else
+          chef_server_rest.put_rest("nodes/#{name}", self)
+        end
       rescue Net::HTTPServerException => e
         raise e unless e.response.code == "404"
         chef_server_rest.post_rest("nodes", self)

data/lib/chef/platform.rb

@@ -250,7 +250,8 @@ class Chef
           },
           :netbsd => {
             :default => {
-              :group => Chef::Provider::Group::Usermod
+              :service => Chef::Provider::Service::Freebsd,
+              :group => Chef::Provider::Group::Groupmod
             }
           },
           :openbsd => {
@@ -348,10 +349,12 @@ class Chef
         return platform, version
       end
 
-      def provider_for_resource(resource)
+      def provider_for_resource(resource, action)
         node = resource.run_context && resource.run_context.node
         raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
-        find_provider_for_node(node, resource).new(resource, resource.run_context)
+        provider = find_provider_for_node(node, resource).new(resource, resource.run_context)
+        provider.action = action
+        provider
       end
 
       def provider_for_node(node, resource_type)

data/lib/chef/provider.rb

@@ -21,19 +21,42 @@ require 'chef/mixin/from_file'
 require 'chef/mixin/convert_to_class_name'
 require 'chef/mixin/recipe_definition_dsl_core'
 require 'chef/mixin/enforce_ownership_and_permissions'
-
+require 'chef/mixin/why_run'
 class Chef
   class Provider
-
     include Chef::Mixin::RecipeDefinitionDSLCore
+    include Chef::Mixin::WhyRun
     include Chef::Mixin::EnforceOwnershipAndPermissions
 
-    attr_accessor :new_resource, :current_resource, :run_context
+    attr_accessor :new_resource
+    attr_accessor :current_resource
+    attr_accessor :run_context
+
+    #--
+    # TODO: this should be a reader, and the action should be passed in the
+    # constructor; however, many/most subclasses override the constructor so
+    # changing the arity would be a breaking change. Change this at the next
+    # break, e.g., Chef 11.
+    attr_accessor :action
+
+    def whyrun_supported?
+      false
+    end
 
     def initialize(new_resource, run_context)
       @new_resource = new_resource
+      @action = action
       @current_resource = nil
       @run_context = run_context
+      @converge_actions = nil
+    end
+
+    def whyrun_mode?
+      Chef::Config[:why_run]
+    end
+
+    def whyrun_supported?
+      false
     end
 
     def node
@@ -53,13 +76,82 @@ class Chef
       raise Chef::Exceptions::Override, "You must override load_current_resource in #{self.to_s}"
     end
 
+    def define_resource_requirements
+    end
+
     def action_nothing
       Chef::Log.debug("Doing nothing for #{@new_resource.to_s}")
       true
     end
 
+    def events
+      run_context.events
+    end
+
+    def run_action(action=nil)
+      @action = action unless action.nil?
+
+      # TODO: it would be preferable to get the action to be executed in the
+      # constructor...
+
+      # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
+      if !whyrun_mode? || whyrun_supported?
+        load_current_resource
+        events.resource_current_state_loaded(@new_resource, @action, @current_resource)
+      elsif whyrun_mode? && !whyrun_supported?
+        events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
+      end
+
+      define_resource_requirements
+      process_resource_requirements
+
+      # user-defined providers including LWRPs may 
+      # not include whyrun support - if they don't support it
+      # we can't execute any actions while we're running in
+      # whyrun mode. Instead we 'fake' whyrun by documenting that
+      # we can't execute the action.
+      # in non-whyrun mode, this will still cause the action to be
+      # executed normally.
+      if whyrun_supported? && !requirements.action_blocked?(@action)
+        send("action_#{@action}")
+      elsif whyrun_mode?
+        events.resource_bypassed(@new_resource, @action, self)
+      else
+        send("action_#{@action}")
+      end
+      converge
+    end
+
+    def process_resource_requirements
+      requirements.run(:all_actions) unless @action == :nothing
+      requirements.run(@action)
+    end
+
+    def converge
+      converge_actions.converge!
+      if converge_actions.empty? && !@new_resource.updated_by_last_action?
+        events.resource_up_to_date(@new_resource, @action)
+      else
+        events.resource_updated(@new_resource, @action)
+        new_resource.updated_by_last_action(true) 
+      end
+    end
+
+    def requirements
+      @requirements ||= ResourceRequirements.new(@new_resource, run_context)
+    end
+
     protected
 
+    def converge_actions
+      @converge_actions ||= ConvergeActions.new(@new_resource, run_context, @action)
+    end
+
+    def converge_by(descriptions, &block)
+      converge_actions.add_action(descriptions, &block)
+    end
+
+
     def recipe_eval(&block)
       # This block has new resource definitions within it, which
       # essentially makes it an in-line Chef run. Save our current
@@ -69,13 +161,15 @@ class Chef
       # TODO: timh,cw: 2010-5-14: This means that the resources within
       # this block cannot interact with resources outside, e.g.,
       # manipulating notifies.
-      saved_run_context = @run_context
-      @run_context = @run_context.dup
-      @run_context.resource_collection = Chef::ResourceCollection.new
-      instance_eval(&block)
-      Chef::Runner.new(@run_context).converge
 
-      @run_context = saved_run_context
+      converge_by ("would evaluate block and run any associated actions") do
+        saved_run_context = @run_context
+        @run_context = @run_context.dup
+        @run_context.resource_collection = Chef::ResourceCollection.new
+        instance_eval(&block)
+        Chef::Runner.new(@run_context).converge
+        @run_context = saved_run_context
+      end
     end
 
     public
@@ -93,6 +187,8 @@ class Chef
 
         new_provider_class = Class.new self do |cls|
 
+          include Chef::Mixin::RecipeDefinitionDSLCore
+
           def load_current_resource
             # silence Chef::Exceptions::Override exception
           end

data/lib/chef/provider/cookbook_file.rb

@@ -23,38 +23,35 @@ require 'tempfile'
 class Chef
   class Provider
     class CookbookFile < Chef::Provider::File
+      def whyrun_supported?
+        true
+      end
 
       def load_current_resource
         @current_resource = Chef::Resource::CookbookFile.new(@new_resource.name)
         @new_resource.path.gsub!(/\\/, "/") # for Windows
         @current_resource.path(@new_resource.path)
+        setup_acl
         @current_resource
       end
 
       def action_create
-        assert_enclosing_directory_exists!
-        if file_cache_location && content_stale?
-          Chef::Log.debug("#{@new_resource} has new contents")
-          backup_new_resource
-          Tempfile.open(::File.basename(@new_resource.name)) do |staging_file|
-            Chef::Log.debug("#{@new_resource} staging #{file_cache_location} to #{staging_file.path}")
-            staging_file.close
-            stage_file_to_tmpdir(staging_file.path)
-            FileUtils.mv(staging_file.path, @new_resource.path)
+        if file_cache_location && content_stale? 
+          description = []
+          description << "create a new cookbook_file #{@new_resource.path}"
+          description << diff_current(file_cache_location)
+          converge_by(description) do
+            Chef::Log.debug("#{@new_resource} has new contents")
+            backup_new_resource
+            deploy_tempfile do |tempfile|
+              Chef::Log.debug("#{@new_resource} staging #{file_cache_location} to #{tempfile.path}")
+              tempfile.close
+              FileUtils.cp(file_cache_location, tempfile.path)
+            end
+            Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
           end
-          Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
-          @new_resource.updated_by_last_action(true)
-        else
-          set_all_access_controls(@new_resource.path)
-        end
-        @new_resource.updated_by_last_action?
-      end
-
-      def action_create_if_missing
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("#{@new_resource} exists at #{@new_resource.path} taking no action.")
         else
-          action_create
+          set_all_access_controls
         end
       end
 
@@ -72,19 +69,6 @@ class Chef
         @new_resource.cookbook || @new_resource.cookbook_name
       end
 
-      # Copy the file from the cookbook cache to a temporary location and then
-      # set its file access control settings.
-      def stage_file_to_tmpdir(staging_file_location)
-        FileUtils.cp(file_cache_location, staging_file_location)
-        set_all_access_controls(staging_file_location)
-      end
-
-      def set_all_access_controls(file)
-        access_controls = Chef::FileAccessControl.new(@new_resource, file)
-        access_controls.set_all
-        @new_resource.updated_by_last_action(access_controls.modified?)
-      end
-
       def backup_new_resource
         if ::File.exists?(@new_resource.path)
           backup @new_resource.path

data/lib/chef/provider/cron.rb

@@ -37,6 +37,10 @@ class Chef
       end
       attr_accessor :cron_exists, :cron_empty
 
+      def whyrun_supported?
+        true
+      end
+      
       def load_current_resource
         crontab_lines = []
         @current_resource = Chef::Resource::Cron.new(@new_resource.name)
@@ -77,7 +81,7 @@ class Chef
 
         @current_resource
       end
-
+      
       def cron_different?
         CRON_ATTRIBUTES.any? do |cron_var|
           !@new_resource.send(cron_var).nil? && @new_resource.send(cron_var) != @current_resource.send(cron_var)
@@ -125,20 +129,23 @@ class Chef
             end
             crontab << line
           end
+
           # Handle edge case where the Chef comment is the last line in the current crontab
           crontab << newcron if cron_found
 
-          write_crontab crontab
-          Chef::Log.info("#{@new_resource} updated crontab entry")
-          @new_resource.updated_by_last_action(true)
+          converge_by("update crontab entry for #{@new_resource}") do
+            write_crontab crontab
+            Chef::Log.info("#{@new_resource} updated crontab entry")
+          end
+
         else
           crontab = read_crontab unless @cron_empty
-
           crontab << newcron
 
-          write_crontab crontab
-          Chef::Log.info("#{@new_resource} added crontab entry")
-          @new_resource.updated_by_last_action(true)
+          converge_by("add crontab entry for #{@new_resource}") do
+            write_crontab crontab
+            Chef::Log.info("#{@new_resource} added crontab entry")
+          end
         end
       end
 
@@ -164,10 +171,12 @@ class Chef
             end
             crontab << line
           end
-
-          write_crontab crontab
-          Chef::Log.info("#{@new_resource} deleted crontab entry")
-          @new_resource.updated_by_last_action(true)
+          description = cron_found ? "remove #{@new_resource.name} from crontab" : 
+            "save unmodified crontab"
+          converge_by(description) do
+            write_crontab crontab
+            Chef::Log.info("#{@new_resource} deleted crontab entry")
+          end
         end
       end
 

data/lib/chef/provider/deploy.rb

@@ -25,6 +25,7 @@ class Chef
   class Provider
     class Deploy < Chef::Provider
 
+      include Chef::Mixin::RecipeDefinitionDSLCore
       include Chef::Mixin::FromFile
       include Chef::Mixin::Command
 
@@ -33,6 +34,8 @@ class Chef
       def initialize(new_resource, run_context)
         super(new_resource, run_context)
 
+        # will resolve to ither git or svn based on resource attributes , 
+        # and will create a resource corresponding to that provider 
         @scm_provider = new_resource.scm_provider.new(new_resource, run_context)
 
         # @configuration is not used by Deploy, it is only for backwards compat with
@@ -41,6 +44,10 @@ class Chef
         @configuration[:environment] = @configuration[:environment] && @configuration[:environment]["RAILS_ENV"]
       end
 
+      def whyrun_supported?
+        true
+      end
+
       def load_current_resource
         @scm_provider.load_current_resource
         @release_path = @new_resource.deploy_to + "/releases/#{release_slug}"
@@ -56,14 +63,40 @@ class Chef
         exec.group(@new_resource.group) if @new_resource.group
         exec.cwd(release_path) unless exec.cwd
         exec.environment(@new_resource.environment) unless exec.environment
-        exec
+        converge_by("execute #{command}") do
+          exec
+        end
+      end
+
+      def define_resource_requirements
+        requirements.assert(:rollback) do |a|
+          a.assertion { all_releases[-2] }
+          a.failure_message(RuntimeError, "There is no release to rollback to!")
+          #There is no reason to assume 2 deployments in a single chef run, hence fails in whyrun.
+        end
+
+        [ @new_resource.before_migrate, @new_resource.before_symlink, 
+          @new_resource.before_restart, @new_resource.after_restart ].each do |script|
+          requirements.assert(:deploy, :force_deploy) do |a|
+            callback_file = "#{release_path}/#{script}"
+            a.assertion do 
+              if script && script.class == String
+                ::File.exist?(callback_file)
+              else
+                true
+              end
+            end
+            a.failure_message(RuntimeError, "Can't find your callback file #{callback_file}")
+            a.whyrun("Would assume callback file #{callback_file} included in release")
+          end
+        end
+
       end
 
       def action_deploy
         save_release_state
-
-        if deployed?(release_path)
-          if current_release?(release_path) 
+        if deployed?(release_path )
+          if current_release?(release_path ) 
             Chef::Log.debug("#{@new_resource} is the latest version")
           else
             rollback_to release_path
@@ -72,16 +105,17 @@ class Chef
 
           with_rollback_on_error do
             deploy
-            @new_resource.updated_by_last_action(true)
           end
         end
       end
 
       def action_force_deploy
         if deployed?(release_path)
-          Chef::Log.info("Already deployed app at #{release_path}, forcing.")
-          FileUtils.rm_rf(release_path)
-          Chef::Log.info("#{@new_resource} forcing deploy of already deployed app at #{release_path}")
+          converge_by("delete deployed app at #{release_path} prior to force-deploy") do 
+            Chef::Log.info("Already deployed app at #{release_path}, forcing.")
+            FileUtils.rm_rf(release_path)
+            Chef::Log.info("#{@new_resource} forcing deploy of already deployed app at #{release_path}")
+          end
         end
 
         # Alternatives:
@@ -90,7 +124,6 @@ class Chef
         # * Do nothing - because deploy is force, it will be retried in short time
         # Because last is simpliest, keep it
         deploy
-        @new_resource.updated_by_last_action(true)
       end
 
       def action_rollback
@@ -99,7 +132,6 @@ class Chef
 
       def rollback_to(target_release_path)
         @release_path = target_release_path
-        raise RuntimeError, "There is no release to rollback to!" unless @release_path
 
         rp_index = all_releases.index(release_path)
         releases_to_nuke = all_releases[(rp_index + 1)..-1]
@@ -107,17 +139,18 @@ class Chef
         rollback
 
         releases_to_nuke.each do |i|
-          Chef::Log.info "#{@new_resource} removing release: #{i}"
-          FileUtils.rm_rf i
+          converge_by("roll back by removing release #{i}") do
+            Chef::Log.info "#{@new_resource} removing release: #{i}"
+            FileUtils.rm_rf i
+          end
           release_deleted(i)
         end
-        @new_resource.updated_by_last_action(true)
       end
 
       def deploy
         enforce_ownership
         verify_directories_exist
-        update_cached_repo
+        update_cached_repo # no converge-by - scm provider will dothis
         copy_cached_repo
         install_gems
         enforce_ownership
@@ -139,6 +172,7 @@ class Chef
         restart
       end
 
+
       def callback(what, callback_code=nil)
         @collection = Chef::ResourceCollection.new
         case callback_code
@@ -146,15 +180,9 @@ class Chef
           Chef::Log.info "#{@new_resource} running callback #{what}"
           recipe_eval(&callback_code)
         when String
-          callback_file = "#{release_path}/#{callback_code}"
-          unless ::File.exist?(callback_file)
-            raise RuntimeError, "Can't find your callback file #{callback_file}"
-          end
-          run_callback_from_file(callback_file)
+          run_callback_from_file("#{release_path}/#{callback_code}")
         when nil
           run_callback_from_file("#{release_path}/deploy/#{what}.rb")
-        else
-          raise RuntimeError, "You gave me a callback I don't know what to do with: #{callback_code.inspect}"
         end
       end
 
@@ -169,8 +197,10 @@ class Chef
             "#{key_and_val.first}='#{key_and_val.last}'"
           end.join(" ")
 
-          Chef::Log.info "#{@new_resource} migrating #{@new_resource.user} with environment #{env_info}"
-          run_command(run_options(:command => @new_resource.migration_command, :cwd=>release_path, :log_level => :info))
+          converge_by("execute migration command #{@new_resource.migration_command}") do
+            Chef::Log.info "#{@new_resource} migrating #{@new_resource.user} with environment #{env_info}"
+            run_command(run_options(:command => @new_resource.migration_command, :cwd=>release_path, :log_level => :info))
+          end
         end
       end
 
@@ -187,16 +217,21 @@ class Chef
             Chef::Log.info("#{@new_resource} restarting app with embedded recipe")
             recipe_eval(&restart_cmd)
           else
-            Chef::Log.info("#{@new_resource} restarting app")
-            run_command(run_options(:command => @new_resource.restart_command, :cwd => @new_resource.current_path))
+            converge_by("restart app using command #{@new_resource.restart_command}") do
+              Chef::Log.info("#{@new_resource} restarting app")
+              run_command(run_options(:command => @new_resource.restart_command, :cwd => @new_resource.current_path))
+            end
           end
         end
       end
 
       def cleanup!
-        all_releases[0..-6].each do |old_release|
-          Chef::Log.info "#{@new_resource} removing old release #{old_release}"
-          FileUtils.rm_rf(old_release)
+        chop = -1 - @new_resource.keep_releases
+        all_releases[0..chop].each do |old_release|
+          converge_by("remove old release #{old_release}") do
+            Chef::Log.info "#{@new_resource} removing old release #{old_release}"
+            FileUtils.rm_rf(old_release)
+          end
           release_deleted(old_release)
         end
       end
@@ -207,6 +242,7 @@ class Chef
 
       def update_cached_repo
         if @new_resource.svn_force_export
+        # TODO assertion, non-recoverable - @scm_provider must be svn if force_export?
           svn_force_export
         else
           run_scm_sync
@@ -214,25 +250,30 @@ class Chef
       end
 
       def run_scm_sync
-        @scm_provider.action_sync
+        @scm_provider.run_action(:sync)
       end
 
       def svn_force_export
         Chef::Log.info "#{@new_resource} exporting source repository"
-        @scm_provider.action_force_export
+        @scm_provider.run_action(:force_export)
       end
 
       def copy_cached_repo
-        FileUtils.mkdir_p(@new_resource.deploy_to + "/releases")
-        run_command(:command => "cp -RPp #{::File.join(@new_resource.destination, ".")} #{release_path}")
-        Chef::Log.info "#{@new_resource} copied the cached checkout to #{release_path}"
-        release_created(release_path)
+        target_dir_path = @new_resource.deploy_to + "/releases"
+        converge_by("deploy from repo to #{@target_dir_path} ") do
+          FileUtils.mkdir_p(target_dir_path)
+          run_command(:command => "cp -RPp #{::File.join(@new_resource.destination, ".")} #{release_path}")
+          Chef::Log.info "#{@new_resource} copied the cached checkout to #{release_path}"
+          release_created(release_path)
+        end
       end
 
       def enforce_ownership
-        FileUtils.chown_R(@new_resource.user, @new_resource.group, @new_resource.deploy_to)
-        Chef::Log.info("#{@new_resource} set user to #{@new_resource.user}") if @new_resource.user
-        Chef::Log.info("#{@new_resource} set group to #{@new_resource.group}") if @new_resource.group
+        converge_by("force ownership of #{@new_resource.deploy_to} to #{@new_resource.group}:#{@new_resource.user}") do
+          FileUtils.chown_R(@new_resource.user, @new_resource.group, @new_resource.deploy_to)
+          Chef::Log.info("#{@new_resource} set user to #{@new_resource.user}") if @new_resource.user
+          Chef::Log.info("#{@new_resource} set group to #{@new_resource.group}") if @new_resource.group
+        end
       end
 
       def verify_directories_exist
@@ -241,26 +282,31 @@ class Chef
       end
 
       def link_current_release_to_production
-        FileUtils.rm_f(@new_resource.current_path)
-        begin
-          FileUtils.ln_sf(release_path, @new_resource.current_path)
-        rescue => e
-          raise Chef::Exceptions::FileNotFound.new("Cannot symlink current release to production: #{e.message}")
+        converge_by(["remove existing link at #{@new_resource.current_path}", 
+                    "link release #{release_path} into production at #{@new_resource.current_path}"]) do
+          FileUtils.rm_f(@new_resource.current_path)
+          begin
+            FileUtils.ln_sf(release_path, @new_resource.current_path)
+            rescue => e
+              raise Chef::Exceptions::FileNotFound.new("Cannot symlink current release to production: #{e.message}")
+            end
+          Chef::Log.info "#{@new_resource} linked release #{release_path} into production at #{@new_resource.current_path}"
         end
-        Chef::Log.info "#{@new_resource} linked release #{release_path} into production at #{@new_resource.current_path}"
         enforce_ownership
       end
 
       def run_symlinks_before_migrate
         links_info = @new_resource.symlink_before_migrate.map { |src, dst| "#{src} => #{dst}" }.join(", ")
-        @new_resource.symlink_before_migrate.each do |src, dest|
-          begin
-            FileUtils.ln_sf(@new_resource.shared_path + "/#{src}", release_path + "/#{dest}")
-          rescue => e
-            raise Chef::Exceptions::FileNotFound.new("Cannot symlink #{@new_resource.shared_path}/#{src} to #{release_path}/#{dest} before migrate: #{e.message}")
+        converge_by("make pre-migration symliinks: #{links_info}") do
+          @new_resource.symlink_before_migrate.each do |src, dest|
+            begin
+              FileUtils.ln_sf(@new_resource.shared_path + "/#{src}", release_path + "/#{dest}")
+            rescue => e
+              raise Chef::Exceptions::FileNotFound.new("Cannot symlink #{@new_resource.shared_path}/#{src} to #{release_path}/#{dest} before migrate: #{e.message}")
+            end
           end
+          Chef::Log.info "#{@new_resource} made pre-migration symlinks"
         end
-        Chef::Log.info "#{@new_resource} made pre-migration symlinks"
       end
 
       def link_tempfiles_to_current_release
@@ -268,17 +314,19 @@ class Chef
         @new_resource.create_dirs_before_symlink.each do |dir| 
           create_dir_unless_exists(release_path + "/#{dir}")
         end
-        Chef::Log.info("#{@new_resource} created directories before symlinking #{dirs_info}")
+        Chef::Log.info("#{@new_resource} created directories before symlinking: #{dirs_info}")
 
         links_info = @new_resource.symlinks.map { |src, dst| "#{src} => #{dst}" }.join(", ")
-        @new_resource.symlinks.each do |src, dest|
-          begin
-            FileUtils.ln_sf(::File.join(@new_resource.shared_path, src), ::File.join(release_path, dest))
-          rescue => e
-            raise Chef::Exceptions::FileNotFound.new("Cannot symlink shared data #{::File.join(@new_resource.shared_path, src)} to #{::File.join(release_path, dest)}: #{e.message}")
+        converge_by("link shared paths into current release:  #{links_info}") do
+          @new_resource.symlinks.each do |src, dest|
+            begin
+              FileUtils.ln_sf(::File.join(@new_resource.shared_path, src), ::File.join(release_path, dest))
+            rescue => e
+              raise Chef::Exceptions::FileNotFound.new("Cannot symlink shared data #{::File.join(@new_resource.shared_path, src)} to #{::File.join(release_path, dest)}: #{e.message}")
+            end
           end
+          Chef::Log.info("#{@new_resource} linked shared paths into current release: #{links_info}")
         end
-        Chef::Log.info("#{@new_resource} linked shared paths into current release: #{links_info}")
         run_symlinks_before_migrate
         enforce_ownership
       end
@@ -288,19 +336,25 @@ class Chef
 
       def purge_tempfiles_from_current_release
         log_info = @new_resource.purge_before_symlink.join(", ")
-        @new_resource.purge_before_symlink.each { |dir| FileUtils.rm_rf(release_path + "/#{dir}") }
-        Chef::Log.info("#{@new_resource} purged directories in checkout #{log_info}")
+        converge_by("purge directories in checkout #{log_info}") do
+          @new_resource.purge_before_symlink.each { |dir| FileUtils.rm_rf(release_path + "/#{dir}") }
+          Chef::Log.info("#{@new_resource} purged directories in checkout #{log_info}")
+        end
       end
 
       protected
 
       # Internal callback, called after copy_cached_repo.
       # Override if you need to keep state externally.
+      # Note that YOU are responsible for implementing whyrun-friendly behavior 
+      # in any actions you take in this callback. 
       def release_created(release_path)
       end
 
-      # Internal callback, called during cleanup! for each old release removed.
+      # Note that YOU are responsible for using appropriate whyrun nomenclature
       # Override if you need to keep state externally.
+      # Note that YOU are responsible for implementing whyrun-friendly behavior 
+      # in any actions you take in this callback. 
       def release_deleted(release_path)
       end
 
@@ -361,20 +415,21 @@ class Chef
           Chef::Log.debug "#{@new_resource} not creating #{dir} because it already exists"
           return false
         end
-
-        begin
-          FileUtils.mkdir_p(dir)
-          Chef::Log.debug "#{@new_resource} created directory #{dir}"
-          if @new_resource.user
-            FileUtils.chown(@new_resource.user, nil, dir)
-            Chef::Log.debug("#{@new_resource} set user to #{@new_resource.user} for #{dir}")
-          end
-          if @new_resource.group
-            FileUtils.chown(nil, @new_resource.group, dir)
-            Chef::Log.debug("#{@new_resource} set group to #{@new_resource.group} for #{dir}")
+        converge_by("create new directory #{dir}") do
+          begin
+            FileUtils.mkdir_p(dir)
+            Chef::Log.debug "#{@new_resource} created directory #{dir}"
+            if @new_resource.user
+              FileUtils.chown(@new_resource.user, nil, dir)
+              Chef::Log.debug("#{@new_resource} set user to #{@new_resource.user} for #{dir}")
+            end
+            if @new_resource.group
+              FileUtils.chown(nil, @new_resource.group, dir)
+              Chef::Log.debug("#{@new_resource} set group to #{@new_resource.group} for #{dir}")
+            end
+          rescue => e
+            raise Chef::Exceptions::FileNotFound.new("Cannot create directory #{dir}: #{e.message}")
           end
-        rescue => e
-          raise Chef::Exceptions::FileNotFound.new("Cannot create directory #{dir}: #{e.message}")
         end
       end
 
@@ -389,9 +444,10 @@ class Chef
             @release_path = previous_release_path
             rollback
           end
-
-          Chef::Log.info "Removing failed deploy #{failed_release}"
-          FileUtils.rm_rf failed_release
+          converge_by("remove failed deploy #{failed_release}") do
+            Chef::Log.info "Removing failed deploy #{failed_release}"
+            FileUtils.rm_rf failed_release
+          end
           release_deleted(failed_release)
         end