chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/provider/mdadm.rb

@@ -24,11 +24,14 @@ class Chef
   class Provider
     class Mdadm < Chef::Provider
 
-      #include Chef::Mixin::Command
       include Chef::Mixin::ShellOut
 
       def popen4
-        raise Exception, "deprecated, bitches"
+        raise Exception, "deprecated"
+      end
+
+      def whyrun_supported?
+        true
       end
 
       def load_current_resource
@@ -38,28 +41,21 @@ class Chef
 
         mdadm = shell_out!("mdadm --detail --scan")
         exists = mdadm.stdout.include?(@new_resource.raid_device)
-        #exists = false
-        # popen4(command) do |pid, stdin, stdout, stderr|
-        #   stdout.each do |line|
-        #     if line.include? @new_resource.raid_device
-        #       exists = true
-        #     end
-        #   end
-        # end
         @current_resource.exists(exists)
       end
 
       def action_create
+
         unless @current_resource.exists
-          command = "yes | mdadm --create #{@new_resource.raid_device} --chunk=#{@new_resource.chunk} --level #{@new_resource.level}"
-          command << " --metadata=#{@new_resource.metadata}"
-          command << " --bitmap=#{@new_resource.bitmap}" if @new_resource.bitmap
-          command << " --raid-devices #{@new_resource.devices.length} #{@new_resource.devices.join(" ")}"
-          Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
-          #pid, stdin, stdout, stderr = popen4(command)
-          shell_out!(command)
-          Chef::Log.info("#{@new_resource} created raid device (#{@new_resource.raid_device})")
-          @new_resource.updated_by_last_action(true)
+          converge_by("create RAID device #{new_resource.raid_device}") do 
+            command = "yes | mdadm --create #{@new_resource.raid_device} --chunk=#{@new_resource.chunk} --level #{@new_resource.level}"
+            command << " --metadata=#{@new_resource.metadata}"
+            command << " --bitmap=#{@new_resource.bitmap}" if @new_resource.bitmap
+            command << " --raid-devices #{@new_resource.devices.length} #{@new_resource.devices.join(" ")}"
+            Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
+            shell_out!(command)
+            Chef::Log.info("#{@new_resource} created raid device (#{@new_resource.raid_device})")
+          end
         else
           Chef::Log.debug("#{@new_resource} raid device already exists, skipping create (#{@new_resource.raid_device})")
         end
@@ -67,11 +63,12 @@ class Chef
 
       def action_assemble
         unless @current_resource.exists
-          command = "yes | mdadm --assemble #{@new_resource.raid_device} #{@new_resource.devices.join(" ")}"
-          Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
-          shell_out!(command)
-          Chef::Log.info("#{@new_resource} assembled raid device (#{@new_resource.raid_device})")
-          @new_resource.updated_by_last_action(true)
+          converge_by("assemble RAID device #{new_resource.raid_device}") do 
+            command = "yes | mdadm --assemble #{@new_resource.raid_device} #{@new_resource.devices.join(" ")}"
+            Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
+            shell_out!(command)
+            Chef::Log.info("#{@new_resource} assembled raid device (#{@new_resource.raid_device})")
+          end
         else
           Chef::Log.debug("#{@new_resource} raid device already exists, skipping assemble (#{@new_resource.raid_device})")
         end
@@ -79,11 +76,12 @@ class Chef
 
       def action_stop
         if @current_resource.exists
-          command = "yes | mdadm --stop #{@new_resource.raid_device}"
-          Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
-          shell_out!(command)
-          Chef::Log.info("#{@new_resource} stopped raid device (#{@new_resource.raid_device})")
-          @new_resource.updated_by_last_action(true)
+          converge_by("stop RAID device #{new_resource.raid_device}") do 
+            command = "yes | mdadm --stop #{@new_resource.raid_device}"
+            Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
+            shell_out!(command)
+            Chef::Log.info("#{@new_resource} stopped raid device (#{@new_resource.raid_device})")
+          end
         else
           Chef::Log.debug("#{@new_resource} raid device doesn't exist (#{@new_resource.raid_device}) - not stopping")
         end

data/lib/chef/provider/mount.rb

@@ -26,12 +26,22 @@ class Chef
 
       include Chef::Mixin::Command
 
+
+      def whyrun_supported?
+        true
+      end
+
+      def load_current_resource
+        true
+      end
+
       def action_mount
         unless @current_resource.mounted
-          status = mount_fs()
-          if status
-            @new_resource.updated_by_last_action(true)
-            Chef::Log.info("#{@new_resource} mounted")
+          converge_by("mount #{@current_resource.device} to #{@current_resource.mount_point}") do 
+            status = mount_fs()
+            if status
+              Chef::Log.info("#{@new_resource} mounted")
+            end
           end
         else
           Chef::Log.debug("#{@new_resource} is already mounted")
@@ -40,10 +50,11 @@ class Chef
 
       def action_umount
         if @current_resource.mounted
-          status = umount_fs()
-          if status
-            @new_resource.updated_by_last_action(true)
-            Chef::Log.info("#{@new_resource} unmounted")
+          converge_by("unmount #{@current_resource.device}") do 
+            status = umount_fs()
+            if status
+              Chef::Log.info("#{@new_resource} unmounted")
+            end
           end
         else
           Chef::Log.debug("#{@new_resource} is already unmounted")
@@ -55,37 +66,40 @@ class Chef
           raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :remount"
         else
           if @current_resource.mounted
-            status = remount_fs()
-            if status
-              @new_resource.updated_by_last_action(true)
-              Chef::Log.info("#{@new_resource} remounted")
+            converge_by("remount #{@current_resource.device}") do 
+              status = remount_fs()
+              if status
+                Chef::Log.info("#{@new_resource} remounted")
+              end
             end
           else
             Chef::Log.debug("#{@new_resource} not mounted, nothing to remount")
           end
         end
       end
-      
+
       def action_enable
         unless @current_resource.enabled
-          status = enable_fs
-          if status
-            @new_resource.updated_by_last_action(true)
-            Chef::Log.info("#{@new_resource} enabled")
-          else
-            Chef::Log.debug("#{@new_resource} already enabled")
+          converge_by("remount #{@current_resource.device}") do 
+            status = enable_fs
+            if status
+              Chef::Log.info("#{@new_resource} enabled")
+            else
+              Chef::Log.debug("#{@new_resource} already enabled")
+            end
           end
         end
       end
-      
+
       def action_disable
         if @current_resource.enabled
-          status = disable_fs
-          if status
-            @new_resource.updated_by_last_action(true)            
-            Chef::Log.info("#{@new_resource} disabled")
-          else
-            Chef::Log.debug("#{@new_resource} already disabled")
+          converge_by("remount #{@current_resource.device}") do 
+            status = disable_fs
+            if status
+              Chef::Log.info("#{@new_resource} disabled")
+            else
+              Chef::Log.debug("#{@new_resource} already disabled")
+            end
           end
         end
       end

data/lib/chef/provider/ohai.rb

@@ -22,20 +22,25 @@ class Chef
   class Provider
     class Ohai < Chef::Provider
 
+      def whyrun_supported?
+        true
+      end
+
       def load_current_resource
         true
       end
 
       def action_reload
-        ohai = ::Ohai::System.new
-        if @new_resource.plugin
-          ohai.require_plugin @new_resource.plugin
-        else
-          ohai.all_plugins
+        converge_by("re-run ohai and merge results into node attributes") do
+          ohai = ::Ohai::System.new
+          if @new_resource.plugin
+            ohai.require_plugin @new_resource.plugin
+          else
+            ohai.all_plugins
+          end
+          node.automatic_attrs.merge! ohai.data
+          Chef::Log.info("#{@new_resource} reloaded")
         end
-        node.automatic_attrs.merge! ohai.data
-        Chef::Log.info("#{@new_resource} reloaded")
-        @new_resource.updated_by_last_action(true)
       end
     end
   end

data/lib/chef/provider/package.rb

@@ -28,64 +28,80 @@ class Chef
       include Chef::Mixin::Command
 
       attr_accessor :candidate_version
-
       def initialize(new_resource, run_context)
         super
         @candidate_version = nil
       end
 
+      def whyrun_supported?
+        true
+      end
+
+      def load_current_resource
+
+      end
+
+      def define_resource_requirements
+        requirements.assert(:install) do |a|
+          a.assertion { ((@new_resource.version != nil) && !(target_version_already_installed?)) \
+            || !(@current_resource.version.nil? && candidate_version.nil?)  }
+          a.failure_message(Chef::Exceptions::Package, "No version specified, and no candidate version available for #{@new_resource.package_name}")
+        end
+
+        requirements.assert(:upgrade) do |a|
+          # Can't upgrade what we don't have
+          a.assertion  { !(@current_resource.version.nil? && candidate_version.nil?) } 
+          a.failure_message(Chef::Exceptions::Package, "No candidate version available for #{@new_resource.package_name}")
+        end
+      end
+
       def action_install
         # If we specified a version, and it's not the current version, move to the specified version
-        if @new_resource.version != nil && !target_version_already_installed?
+        if !@new_resource.version.nil? && !(target_version_already_installed?)
           install_version = @new_resource.version
         # If it's not installed at all, install it
-        elsif @current_resource.version == nil
+        elsif @current_resource.version.nil?
           install_version = candidate_version
         else
           Chef::Log.debug("#{@new_resource} is already installed - nothing to do")
           return
         end
 
-        unless install_version
-          raise(Chef::Exceptions::Package, "No version specified, and no candidate version available for #{@new_resource.package_name}")
-        end
-
-
         # We need to make sure we handle the preseed file
         if @new_resource.response_file
-          preseed_package(@new_resource.package_name, install_version)
+          if preseed_file = get_preseed_file(@new_resource.package_name, install_version)
+            converge_by("preseed package #{@new_resource.package_name}") do  
+              preseed_package(preseed_file)
+            end 
+          end
         end
-
-        status = install_package(@new_resource.package_name, install_version)
-        if status
-          @new_resource.updated_by_last_action(true)
+        description = install_version ? "version #{install_version} of" : ""
+        converge_by("install #{description} package #{@new_resource.package_name}") do
+          install_package(@new_resource.package_name, install_version)
         end
-        Chef::Log.info("#{@new_resource} installed version #{install_version}")
       end
 
       def action_upgrade
-        # Can't upgrade what we don't have
-        if @current_resource.version.nil? && candidate_version.nil?
-          raise(Chef::Exceptions::Package, "No candidate version available for #{@new_resource.package_name}")
-        elsif candidate_version.nil?
+        if candidate_version.nil?
           Chef::Log.debug("#{@new_resource} no candidate version - nothing to do")
         elsif @current_resource.version == candidate_version
           Chef::Log.debug("#{@new_resource} is at the latest version - nothing to do")
         else
           orig_version = @current_resource.version || "uninstalled"
-          status = upgrade_package(@new_resource.package_name, candidate_version)
-          if status
-            @new_resource.updated_by_last_action(true)
+          converge_by("upgrade package #{@new_resource.package_name} from #{orig_version} to #{candidate_version}") do
+            status = upgrade_package(@new_resource.package_name, candidate_version)
+            Chef::Log.info("#{@new_resource} upgraded from #{orig_version} to #{candidate_version}")
           end
-          Chef::Log.info("#{@new_resource} upgraded from #{orig_version} to #{candidate_version}")
         end
       end
 
       def action_remove
         if removing_package?
-          remove_package(@current_resource.package_name, @new_resource.version)
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} removed")
+          description = @new_resource.version ? "version #{@new_resource.version} of " :  ""
+          converge_by("remove #{description} package #{@current_resource.package_name}") do
+            remove_package(@current_resource.package_name, @new_resource.version)
+            Chef::Log.info("#{@new_resource} removed")
+          end
         else
           Chef::Log.debug("#{@new_resource} package does not exist - nothing to do")
         end
@@ -105,9 +121,11 @@ class Chef
 
       def action_purge
         if removing_package?
-          purge_package(@current_resource.package_name, @new_resource.version)
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} purged")
+          description = @new_resource.version ? "version #{@new_resource.version} of" : ""
+          converge_by("purge #{description} package #{@current_resource.package_name}") do
+            purge_package(@current_resource.package_name, @new_resource.version)
+            Chef::Log.info("#{@new_resource} purged")
+          end
         end
       end
 
@@ -122,15 +140,15 @@ class Chef
           return
         end
 
-        status = preseed_package(@new_resource.package_name, @current_resource.version)
-        unless status then
+        if preseed_file = get_preseed_file(@new_resource.package_name, @current_resource.version)
+          converge_by("reconfigure package #{@new_resource.package_name}") do
+            preseed_package(preseed_file)
+            status = reconfig_package(@new_resource.package_name, @current_resource.version)
+            Chef::Log.info("#{@new_resource} reconfigured")
+          end
+        else
           Chef::Log.debug("#{@new_resource} preseeding has not changed - nothing to do")
-          return
         end
-
-        status = reconfig_package(@new_resource.package_name, @current_resource.version)
-        @new_resource.updated_by_last_action(true) if status
-        Chef::Log.info("#{@new_resource} reconfigured")
       end
 
       def install_package(name, version)
@@ -149,8 +167,8 @@ class Chef
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :purge"
       end
 
-      def preseed_package(name, version)
-        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support pre-seeding package install/upgrade instructions - don't ask it to!"
+      def preseed_package(file)
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support pre-seeding package install/upgrade instructions"
       end
 
       def reconfig_package(name, version)
@@ -159,7 +177,7 @@ class Chef
 
       def get_preseed_file(name, version)
         resource = preseed_resource(name, version)
-        resource.run_action('create')
+        resource.run_action(:create)
         Chef::Log.debug("#{@new_resource} fetched preseed file to #{resource.path}")
 
         if resource.updated_by_last_action?
@@ -182,7 +200,7 @@ class Chef
           remote_file.cookbook_name = @new_resource.cookbook_name
           remote_file.source(@new_resource.response_file)
           remote_file.backup(false)
-          provider = Chef::Platform.provider_for_resource(remote_file)
+          provider = Chef::Platform.provider_for_resource(remote_file, :create)
           provider.template_location
         rescue
           Chef::Log.debug("#{@new_resource} fetching preseed file via Template resource failed, fallback to CookbookFile resource")
@@ -199,8 +217,6 @@ class Chef
         options ? " #{options}" : ""
       end
 
-    private
-
       def target_version_already_installed?
         @new_resource.version == @current_resource.version
       end

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

@@ -118,17 +118,14 @@ class Chef
           )
         end
 
-        def preseed_package(name, version)
-          preseed_file = get_preseed_file(name, version)
-          if preseed_file
-            Chef::Log.info("#{@new_resource} pre-seeding package installation instructions")
-            run_command_with_systems_locale(
-              :command => "debconf-set-selections #{preseed_file}",
-              :environment => {
-                "DEBIAN_FRONTEND" => "noninteractive"
-              }
-            )
-          end
+        def preseed_package(preseed_file)
+          Chef::Log.info("#{@new_resource} pre-seeding package installation instructions")
+          run_command_with_systems_locale(
+            :command => "debconf-set-selections #{preseed_file}",
+            :environment => {
+              "DEBIAN_FRONTEND" => "noninteractive"
+            }
+          )
         end
 
         def reconfig_package(name, version)

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

@@ -30,33 +30,46 @@ class Chef
         DPKG_VERSION = /^Version: (.+)$/
 
         include Chef::Mixin::GetSourceFromPackage
+        def define_resource_requirements
+          super
+          requirements.assert(:install) do |a| 
+            a.assertion{ not @new_resource.source.nil? }
+            a.failure_message Chef::Exceptions::Package, "Source for package #{@new_resource.name} required for action install"
+          end
+
+          # TODO this was originally written for any action in which .source is provided
+          # but would it make more sense to only look at source if the action is :install?
+          requirements.assert(:all_actions) do |a| 
+            a.assertion { @source_exists }
+            a.failure_message Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
+            a.whyrun "Assuming it would have been previously downloaded."
+          end
+        end
 
         def load_current_resource
+          @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 the source was not set, and we're installing, fail
-          if Array(@new_resource.action).include?(:install) && @new_resource.source.nil?
-            raise Chef::Exceptions::Package, "Source for package #{@new_resource.name} required for action install"
-          end
-
-          # We only -need- source for action install
           if @new_resource.source
-            unless ::File.exists?(@new_resource.source)
-              raise Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
-            end
-
-            # Get information from the package if supplied
-            Chef::Log.debug("#{@new_resource} checking dpkg status")
-            status = popen4("dpkg-deb -W #{@new_resource.source}") do |pid, stdin, stdout, stderr|
-              stdout.each_line do |line|
-                if pkginfo = DPKG_INFO.match(line)
-                  @current_resource.package_name(pkginfo[1])
-                  @new_resource.version(pkginfo[2])
+            @source_exists = ::File.exists?(@new_resource.source) 
+            if @source_exists
+              # Get information from the package if supplied
+              Chef::Log.debug("#{@new_resource} checking dpkg status")
+              status = popen4("dpkg-deb -W #{@new_resource.source}") do |pid, stdin, stdout, stderr|
+                stdout.each_line do |line|
+                  if pkginfo = DPKG_INFO.match(line)
+                    @current_resource.package_name(pkginfo[1])
+                    @new_resource.version(pkginfo[2])
+                  end
                 end
               end
+            else
+              # Source provided but not valid means we can't safely do further processing
+              return
             end
+
           end
           
           # Check to see if it is installed