chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/provider/package/rpm.rb

@@ -27,14 +27,33 @@ class Chef
 
         include Chef::Mixin::GetSourceFromPackage
 
+        def define_resource_requirements
+          super
+
+          requirements.assert(:all_actions) do |a| 
+            a.assertion { @package_source_exists }
+            a.failure_message Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
+            a.whyrun "Assuming package #{@new_resource.name} would have been made available."
+          end
+          requirements.assert(:all_actions) do |a| 
+            a.assertion { !@rpm_status.nil? && (@rpm_status.exitstatus == 0 || @rpm_status.exitstatus == 1) } 
+            a.failure_message Chef::Exceptions::Package, "Unable to determine current version due to RPM failure. Detail: #{@rpm_status.inspect}"
+            a.whyrun "Assuming current version would have been determined for package#{@new_resource.name}."
+          end
+        end
+        
         def load_current_resource
+          @package_source_provided = true
+          @package_source_exists = true
+
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)
           @new_resource.version(nil)
           
           if @new_resource.source
             unless ::File.exists?(@new_resource.source)
-              raise Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
+              @package_source_exists = false
+              return
             end
             
             Chef::Log.debug("#{@new_resource} checking rpm status")
@@ -49,12 +68,13 @@ class Chef
             end
           else
             if Array(@new_resource.action).include?(:install)
-              raise Chef::Exceptions::Package, "Source for package #{@new_resource.name} required for action install"
+              @package_source_exists = false
+              return
             end
           end
           
           Chef::Log.debug("#{@new_resource} checking install state")
-          status = popen4("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@current_resource.package_name}") do |pid, stdin, stdout, stderr|
+          @rpm_status = popen4("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@current_resource.package_name}") do |pid, stdin, stdout, stderr|
             stdout.each do |line|
               case line
               when /([\w\d_.-]+)\s([\w\d_.-]+)/
@@ -64,9 +84,6 @@ class Chef
             end
           end
           
-          unless status.exitstatus == 0 || status.exitstatus == 1
-            raise Chef::Exceptions::Package, "rpm failed - #{status.inspect}!"
-          end
           
           @current_resource
         end

data/lib/chef/provider/remote_directory.rb

@@ -63,11 +63,15 @@ class Chef
         if @new_resource.purge
           unmanaged_files.sort.reverse.each do |f|
             if ::File.directory?(f) && !::File.symlink?(f)
-              Dir::rmdir(f)
-              Chef::Log.debug("#{@new_resource} removed directory #{f}")
+              converge_by("delete unmanaged directory #{f}") do
+                Dir::rmdir(f)
+                Chef::Log.debug("#{@new_resource} removed directory #{f}")
+              end
             else
-              ::File.delete(f)
-              Chef::Log.debug("#{@new_resource} deleted file #{f}")
+              converge_by("delete unmanaged file #{f}") do
+                ::File.delete(f)
+                Chef::Log.debug("#{@new_resource} deleted file #{f}")
+              end
             end
           end
         end

data/lib/chef/provider/remote_file.rb

@@ -32,35 +32,33 @@ class Chef
       end
 
       def action_create
-        assert_enclosing_directory_exists!
-
         Chef::Log.debug("#{@new_resource} checking for changes")
 
         if current_resource_matches_target_checksum?
           Chef::Log.debug("#{@new_resource} checksum matches target checksum (#{@new_resource.checksum}) - not updating")
         else
-          Chef::REST.new(@new_resource.source, nil, nil, http_client_opts).fetch(@new_resource.source) do |raw_file|
-            if matches_current_checksum?(raw_file)
-              Chef::Log.debug "#{@new_resource} target and source checksums are the same - not updating"
-            else
+          rest = Chef::REST.new(@new_resource.source, nil, nil, http_client_opts)
+          raw_file = rest.streaming_request(rest.create_url(@new_resource.source), {})
+          if matches_current_checksum?(raw_file)
+            Chef::Log.debug "#{@new_resource} target and source checksums are the same - not updating"
+          else
+            description = [] 
+            description << "copy file downloaded from #{@new_resource.source} into #{@new_resource.path}"
+            description << diff_current(raw_file.path)
+            converge_by(description) do
               backup_new_resource
               FileUtils.cp raw_file.path, @new_resource.path
               Chef::Log.info "#{@new_resource} updated"
-              @new_resource.updated_by_last_action(true)
+              raw_file.close!
+            end
+            # whyrun mode cleanup - the temp file will never be used,
+            # so close/unlink it here. 
+            if whyrun_mode?
+              raw_file.close!
             end
           end
         end
-        enforce_ownership_and_permissions
-
-        @new_resource.updated_by_last_action?
-      end
-
-      def action_create_if_missing
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("#{@new_resource} exists, taking no action.")
-        else
-          action_create
-        end
+        set_all_access_controls
       end
 
       def current_resource_matches_target_checksum?

data/lib/chef/provider/resource_update.rb

@@ -0,0 +1,55 @@
+
+class Chef
+  class Provider
+
+    # {
+    #    "run_id" : "1000",
+    #    "resource" : { 
+    #         "type" : "file",
+    #         "name" : "/etc/passwd", 
+    #         "start_time" : "2012-01-09T08:15:30-05:00",
+    #         "end_time" : "2012-01-09T08:15:30-05:00",
+    #         "status" : "modified",
+    #         "initial_state" : "exists", 
+    #         "final_state" : "modified", 
+    #         "before" : { 
+    #              "group" : "root", 
+    #              "owner" : "root",
+    #              "checksum" : "xyz"
+    #         },
+    #         "after" : { 
+    #              "group" : "root", 
+    #              "owner" : "root",
+    #              "checksum" : "abc"
+    #         },
+    #         "delta" : "escaped delta goes here"
+    #    },
+    #    "event_data" : "" 
+    # }
+
+    class ResourceUpdate
+
+      attr_accessor :type
+      attr_accessor :name
+      attr_accessor :duration #ms
+      attr_accessor :status
+      attr_accessor :initial_state
+      attr_accessor :final_state
+      attr_accessor :initial_properties
+      attr_accessor :final_properties
+      attr_accessor :event_data # e.g., a diff.
+
+      def initial_state_from_resource(resource)
+        @initial_properties = resource.to_hash
+      end
+
+      def updated_state_from_resource(resource)
+        @final_properties = resource.to_hash
+      end
+
+    end
+  end
+end
+
+
+

data/lib/chef/provider/route.rb

@@ -80,6 +80,10 @@ class Chef::Provider::Route < Chef::Provider
       end
     end
 
+    def whyrun_supported?
+      true
+    end
+
     def load_current_resource
       self.is_running = false
 
@@ -128,10 +132,10 @@ class Chef::Provider::Route < Chef::Provider
         Chef::Log.debug("#{@new_resource} route already active - nothing to do")
       else
         command = generate_command(:add)
-
-        run_command( :command => command )
-        Chef::Log.info("#{@new_resource} added")
-        @new_resource.updated_by_last_action(true)
+        converge_by ("run #{ command } to add route") do
+          run_command( :command => command )
+          Chef::Log.info("#{@new_resource} added")
+        end
       end
 
       #for now we always write the file (ugly but its what it is)
@@ -141,10 +145,10 @@ class Chef::Provider::Route < Chef::Provider
     def action_delete
       if is_running
         command = generate_command(:delete)
-
-        run_command( :command => command )
-        Chef::Log.info("#{@new_resource} removed")
-        @new_resource.updated_by_last_action(true)
+        converge_by ("run #{ command } to delete route ") do
+          run_command( :command => command )
+          Chef::Log.info("#{@new_resource} removed")
+        end
       else
         Chef::Log.debug("#{@new_resource} route does not exist - nothing to do")
       end
@@ -175,10 +179,13 @@ class Chef::Provider::Route < Chef::Provider
           end
         end
         conf.each do |k, v|
-          network_file = ::File.new("/etc/sysconfig/network-scripts/route-#{k}", "w")
-          network_file.puts(conf[k])
-          Chef::Log.debug("#{@new_resource} writing route.#{k}\n#{conf[k]}")
-          network_file.close
+          network_file_name = "/etc/sysconfig/network-scripts/route-#{k}"
+          converge_by ("write route route.#{k}\n#{conf[k]} to #{ network_file_name }") do
+            network_file = ::File.new(network_file_name, "w")
+            network_file.puts(conf[k])
+            Chef::Log.debug("#{@new_resource} writing route.#{k}\n#{conf[k]}")
+            network_file.close
+          end
         end
       end
     end

data/lib/chef/provider/ruby_block.rb

@@ -20,14 +20,19 @@
 class Chef
   class Provider
     class RubyBlock < Chef::Provider
+      def whyrun_supported?
+        true
+      end
+
       def load_current_resource
         true
       end
 
       def action_create
-        @new_resource.block.call
-				Chef::Log.info("#{@new_resource} called")
-        @new_resource.updated_by_last_action(true)
+        converge_by("execute the ruby block #{@new_resource.name}") do 
+          @new_resource.block.call
+          Chef::Log.info("#{@new_resource} called")
+        end
       end
     end
   end

data/lib/chef/provider/script.rb

@@ -31,8 +31,10 @@ class Chef
 
         @new_resource.command("\"#{@new_resource.interpreter}\" #{@new_resource.flags} \"#{script_file.path}\"")
         super
-      ensure
-        unlink_script_file
+        converge_by(nil) do
+          # ensure script is unlinked at end of converge!
+          unlink_script_file
+        end
       end
 
       def set_owner_and_group

data/lib/chef/provider/service.rb

@@ -30,12 +30,29 @@ class Chef
         @enabled = nil
       end
 
+      def whyrun_supported?
+        true
+      end
+
+      def shared_resource_requirements
+      end
+
+      def define_resource_requirements
+       requirements.assert(:reload) do |a|
+         a.assertion { @new_resource.supports[:reload] || @new_resource.reload_command }
+         a.failure_message Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :reload"
+         # if a service is not declared to support reload, that won't
+         # typically change during the course of a run - so no whyrun
+         # alternative here. 
+       end
+      end
+
       def action_enable
         if @current_resource.enabled
           Chef::Log.debug("#{@new_resource} already enabled - nothing to do")
         else
-          if enable_service
-            @new_resource.updated_by_last_action(true)
+          converge_by("enable service #{@new_resource}") do
+            enable_service
             Chef::Log.info("#{@new_resource} enabled")
           end
         end
@@ -43,8 +60,8 @@ class Chef
 
       def action_disable
         if @current_resource.enabled
-          if disable_service
-            @new_resource.updated_by_last_action(true)
+          converge_by("disable service #{@new_resource}") do
+            disable_service
             Chef::Log.info("#{@new_resource} disabled")
           end
         else
@@ -54,40 +71,37 @@ class Chef
 
       def action_start
         unless @current_resource.running
-          if start_service
-            @new_resource.updated_by_last_action(true)
+          converge_by("start service #{@new_resource}") do
+            start_service
             Chef::Log.info("#{@new_resource} started")
           end
         else
           Chef::Log.debug("#{@new_resource} already running - nothing to do")
-        end 
+        end
       end
 
       def action_stop
         if @current_resource.running
-          if stop_service
-            @new_resource.updated_by_last_action(true)
+          converge_by("stop service #{@new_resource}") do
+            stop_service
             Chef::Log.info("#{@new_resource} stopped")
           end
         else
           Chef::Log.debug("#{@new_resource} already stopped - nothing to do")
-        end 
+        end
       end
-      
+
       def action_restart
-        if restart_service
-          @new_resource.updated_by_last_action(true)
+        converge_by("restart service #{@new_resource}") do
+          restart_service
           Chef::Log.info("#{@new_resource} restarted")
         end
       end
 
       def action_reload
-        unless (@new_resource.supports[:reload] || @new_resource.reload_command)
-          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :reload"
-        end
         if @current_resource.running
-          if reload_service
-            @new_resource.updated_by_last_action(true)
+          converge_by("disable service #{@new_resource}") do
+            reload_service
             Chef::Log.info("#{@new_resource} reloaded")
           end
         end
@@ -107,8 +121,8 @@ class Chef
 
       def stop_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :stop"
-      end 
-      
+      end
+
       def restart_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :restart"
       end
@@ -116,7 +130,7 @@ class Chef
       def reload_service
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :restart"
       end
- 
+
     end
   end
 end

data/lib/chef/provider/service/arch.rb

@@ -27,14 +27,11 @@ class Chef::Provider::Service::Arch < Chef::Provider::Service::Init
   end
 
   def load_current_resource
-
-    raise Chef::Exceptions::Service unless ::File.exists?("/etc/rc.conf")
-    raise Chef::Exceptions::Service unless ::File.read("/etc/rc.conf").match(/DAEMONS=\((.*)\)/m)
-
+    raise Chef::Exceptions::Service, "Could not find /etc/rc.conf"  unless ::File.exists?("/etc/rc.conf")
+    raise Chef::Exceptions::Service, "No DAEMONS found in /etc/rc.conf"  unless ::File.read("/etc/rc.conf").match(/DAEMONS=\((.*)\)/m)
     super
 
     @current_resource.enabled(daemons.include?(@current_resource.service_name))
-
     @current_resource
   end
 

data/lib/chef/provider/service/debian.rb

@@ -29,23 +29,47 @@ class Chef
 
         def load_current_resource
           super
-
+          @priority_success = true
+          @rcd_status = nil
           @current_resource.priority(get_priority)
           @current_resource.enabled(service_currently_enabled?(@current_resource.priority))
           @current_resource
         end
 
-        def assert_update_rcd_available
-          unless ::File.exists? "/usr/sbin/update-rc.d"
-            raise Chef::Exceptions::Service, "/usr/sbin/update-rc.d does not exist!"
+        def define_resource_requirements
+          # do not call super here, inherit only shared_requirements
+          shared_resource_requirements
+          requirements.assert(:all_actions) do |a|
+            update_rcd = "/usr/sbin/update-rc.d"
+            a.assertion { ::File.exists? update_rcd } 
+            a.failure_message Chef::Exceptions::Service, "#{update_rcd} does not exist!"
+            # no whyrun recovery - this is a base system component of debian
+            # distros and must be present 
+          end 
+
+          requirements.assert(:all_actions) do |a|
+            a.assertion { @priority_success } 
+            a.failure_message  Chef::Exceptions::Service, "/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} failed - #{@rcd_status.inspect}"
+            # This can happen if the service is not yet installed,so we'll fake it. 
+            a.whyrun ["Unable to determine priority of service, assuming service would have been correctly installed earlier in the run.", 
+                      "Assigning temporary priorities to continue.",
+                      "If this service is not properly installed prior to this point, this will fail."] do
+              temp_priorities = {"6"=>[:stop, "20"],
+                "0"=>[:stop, "20"],
+                "1"=>[:stop, "20"],
+                "2"=>[:start, "20"],
+                "3"=>[:start, "20"],
+                "4"=>[:start, "20"],
+                "5"=>[:start, "20"]}
+              @current_resource.priority(temp_priorities)
+            end
           end
         end
 
         def get_priority
-          assert_update_rcd_available
           priority = {}
 
-          status = popen4("/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} remove") do |pid, stdin, stdout, stderr|
+          @rcd_status = popen4("/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} remove") do |pid, stdin, stdout, stderr|
 
             [stdout, stderr].each do |iop|
               iop.each_line do |line|
@@ -62,18 +86,16 @@ class Chef
             end
           end
 
-          unless status.exitstatus == 0
-            raise Chef::Exceptions::Service, "/usr/sbin/update-rc.d -n -f #{@current_resource.service_name} failed - #{status.inspect}"
+          unless @rcd_status.exitstatus == 0
+            @priority_success = false
           end
           priority
         end
 
         def service_currently_enabled?(priority)
           enabled = false
-
           priority.each { |runlevel, arguments|
             Chef::Log.debug("#{@new_resource} runlevel #{runlevel}, action #{arguments[0]}, priority #{arguments[1]}")
-            
             # if we are in a update-rc.d default startup runlevel && we start in this runlevel
             if (2..5).include?(runlevel.to_i) && arguments[0] == :start
               enabled = true