chef 10.12.0 → 10.14.0.beta.1

data/lib/chef/provider/directory.rb

@@ -26,43 +26,98 @@ require 'fileutils'
 class Chef
   class Provider
     class Directory < Chef::Provider::File
+      def whyrun_supported?
+        true
+      end
+
       def load_current_resource
         @current_resource = Chef::Resource::Directory.new(@new_resource.name)
         @current_resource.path(@new_resource.path)
-        if ::File.exist?(@current_resource.path) && ::File.directory?(@current_resource.path)
-          cstats = ::File.stat(@current_resource.path)
-          @current_resource.owner(cstats.uid)
-          @current_resource.group(cstats.gid)
-          @current_resource.mode("%o" % (cstats.mode & 007777))
-        end
+        setup_acl
         @current_resource
       end
+      def define_resource_requirements
+        # this must be evaluated before whyrun messages are printed
+        access_controls.requires_changes?
 
-      def action_create
-        unless ::File.exists?(@new_resource.path)
-          if @new_resource.recursive == true
-            ::FileUtils.mkdir_p(@new_resource.path)
-          else
-            ::Dir.mkdir(@new_resource.path)
+        requirements.assert(:create) do |a|
+          # Make sure the parent dir exists, or else fail.
+          # for why run, print a message explaining the potential error.
+          parent_directory = ::File.dirname(@new_resource.path)
+          a.assertion { @new_resource.recursive || ::File.directory?(parent_directory) }
+          a.failure_message(Chef::Exceptions::EnclosingDirectoryDoesNotExist, "Parent directory #{parent_directory} does not exist, cannot create #{@new_resource.path}")
+          a.whyrun("Assuming directory #{parent_directory} would have been created")
+        end
+
+        requirements.assert(:create) do |a|
+          parent_directory = ::File.dirname(@new_resource.path)
+          a.assertion do
+            if @new_resource.recursive
+              # find the lowest-level directory in @new_resource.path that already exists
+              # make sure we have write permissions to that directory
+              is_parent_writable = lambda do |base_dir|
+                base_dir = ::File.dirname(base_dir) 
+                if ::File.exist?(base_dir) 
+                  ::File.writable?(base_dir)
+                else
+                  is_parent_writable.call(base_dir)
+                end
+              end
+              is_parent_writable.call(@new_resource.path)
+            else
+              # in why run mode & parent directory does not exist no permissions check is required
+              # If not in why run, permissions must be valid and we rely on prior assertion that dir exists
+              if !whyrun_mode? || ::File.exist?(parent_directory) 
+                ::File.writable?(parent_directory)
+              else
+                true
+              end
+            end
           end
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} created directory #{@new_resource.path}")
+          a.failure_message(Chef::Exceptions::InsufficientPermissions, 
+            "Cannot create #{@new_resource} at #{@new_resource.path} due to insufficient permissions")
+        end
+
+        requirements.assert(:delete) do |a| 
+          a.assertion do 
+            if ::File.exist?(@new_resource.path)
+              ::File.directory?(@new_resource.path) && ::File.writable?(@new_resource.path) 
+            else
+              true
+            end
+          end
+          a.failure_message(RuntimeError, "Cannot delete #{@new_resource} at #{@new_resource.path}!")
+          # No why-run handling here: 
+          #  * if we don't have permissions, this is unlikely to be changed earlier in the run
+          #  * if the target is a file (not a dir), there's no reasonable path by which this would have been changed
+        end
+      end
+
+      def action_create
+        unless ::File.exist?(@new_resource.path)
+          converge_by("create new directory #{@new_resource.path}") do 
+            if @new_resource.recursive == true
+              ::FileUtils.mkdir_p(@new_resource.path)
+            else
+              ::Dir.mkdir(@new_resource.path)
+            end
+            Chef::Log.info("#{@new_resource} created directory #{@new_resource.path}")
+          end 
         end
-        enforce_ownership_and_permissions
+        set_all_access_controls
       end
 
       def action_delete
-        if ::File.directory?(@new_resource.path) && ::File.writable?(@new_resource.path)
-          if @new_resource.recursive == true
-            FileUtils.rm_rf(@new_resource.path)
-            Chef::Log.info("#{@new_resource} deleted #{@new_resource.path} recursively")
-          else
-            ::Dir.delete(@new_resource.path)
-            Chef::Log.info("#{@new_resource} deleted #{@new_resource.path}")
+        if ::File.exist?(@new_resource.path)
+          converge_by("delete existing directory #{@new_resource.path}") do
+            if @new_resource.recursive == true
+              FileUtils.rm_rf(@new_resource.path)
+              Chef::Log.info("#{@new_resource} deleted #{@new_resource.path} recursively")
+            else
+              ::Dir.delete(@new_resource.path)
+              Chef::Log.info("#{@new_resource} deleted #{@new_resource.path}")
+            end
           end
-          @new_resource.updated_by_last_action(true)
-        else
-          raise RuntimeError, "Cannot delete #{@new_resource} at #{@new_resource_path}!" if ::File.exists?(@new_resource.path)
         end
       end
     end

data/lib/chef/provider/erl_call.rb

@@ -29,6 +29,10 @@ class Chef
         super(node, new_resource)
       end
 
+      def whyrun_supported?
+        true
+      end
+      
       def load_current_resource
         true
       end
@@ -55,45 +59,46 @@ class Chef
 
         command = "erl_call -e #{distributed} #{node} #{cookie}"
 
-        begin
-          pid, stdin, stdout, stderr = popen4(command, :waitlast => true)
+        converge_by("run erlang block") do
+          begin
+            pid, stdin, stdout, stderr = popen4(command, :waitlast => true)
 
-          Chef::Log.debug("#{@new_resource} running")
-          Chef::Log.debug("#{@new_resource} command: #{command}")
-          Chef::Log.debug("#{@new_resource} code: #{@new_resource.code}")
+            Chef::Log.debug("#{@new_resource} running")
+            Chef::Log.debug("#{@new_resource} command: #{command}")
+            Chef::Log.debug("#{@new_resource} code: #{@new_resource.code}")
 
-          @new_resource.code.each_line { |line| stdin.puts(line.chomp) }
+            @new_resource.code.each_line { |line| stdin.puts(line.chomp) }
 
-          stdin.close
+            stdin.close
 
-          Chef::Log.debug("#{@new_resource} output: ")
+            Chef::Log.debug("#{@new_resource} output: ")
 
-          stdout_output = ""
-          stdout.each_line { |line| stdout_output << line }
-          stdout.close
+            stdout_output = ""
+            stdout.each_line { |line| stdout_output << line }
+            stdout.close
 
-          stderr_output = ""
-          stderr.each_line { |line| stderr_output << line }
-          stderr.close
+            stderr_output = ""
+            stderr.each_line { |line| stderr_output << line }
+            stderr.close
 
-          # fail if stderr contains anything
-          if stderr_output.length > 0
-            raise Chef::Exceptions::ErlCall, stderr_output
-          end
+            # fail if stderr contains anything
+            if stderr_output.length > 0
+              raise Chef::Exceptions::ErlCall, stderr_output
+            end
 
-          # fail if the first 4 characters aren't "{ok,"
-          unless stdout_output[0..3].include?('{ok,')
-            raise Chef::Exceptions::ErlCall, stdout_output
-          end
+            # fail if the first 4 characters aren't "{ok,"
+            unless stdout_output[0..3].include?('{ok,')
+              raise Chef::Exceptions::ErlCall, stdout_output
+            end
 
-          @new_resource.updated_by_last_action(true)
+            @new_resource.updated_by_last_action(true)
 
-          Chef::Log.debug("#{@new_resource} #{stdout_output}")
-          Chef::Log.info("#{@new_resouce} ran successfully")
-        ensure
-          Process.wait(pid) if pid
+            Chef::Log.debug("#{@new_resource} #{stdout_output}")
+            Chef::Log.info("#{@new_resouce} ran successfully")
+          ensure
+            Process.wait(pid) if pid
+          end
         end
-
       end
 
     end

data/lib/chef/provider/execute.rb

@@ -29,6 +29,10 @@ class Chef
       def load_current_resource
         true
       end
+      
+      def whyrun_supported?
+        true
+      end
 
       def action_run
         opts = {}
@@ -54,12 +58,11 @@ class Chef
         if STDOUT.tty? && !Chef::Config[:daemon] && Chef::Log.info?
           opts[:live_stream] = STDOUT
         end
-
-        result = shell_out!(@new_resource.command, opts)
-        @new_resource.updated_by_last_action(true)
-        Chef::Log.info("#{@new_resource} ran successfully")
+        converge_by("execute #{@new_resource.command}") do 
+          result = shell_out!(@new_resource.command, opts)
+          Chef::Log.info("#{@new_resource} ran successfully")
+        end
       end
-
     end
   end
 end

data/lib/chef/provider/file.rb

@@ -23,11 +23,15 @@ require 'chef/mixin/checksum'
 require 'chef/provider'
 require 'etc'
 require 'fileutils'
+require 'chef/scan_access_control'
+require 'chef/mixin/shell_out'
 
 class Chef
+
   class Provider
     class File < Chef::Provider
       include Chef::Mixin::Checksum
+      include Chef::Mixin::ShellOut
 
       def negative_complement(big)
         if big > 1073741823 # Fixnum max
@@ -42,11 +46,84 @@ class Chef
 
       private :negative_complement, :octal_mode
 
+      def diff_current_from_content source_content
+        result = nil
+        Tempfile.open("chef-diff") do |file| 
+          file.write source_content
+          file.close 
+          result = diff_current file.path
+        end
+        result
+      end
+
+      def diff_current source_path
+        begin
+          # -N: Treat missing files as empty
+          # -u: Unified diff format
+          result = shell_out("diff -u -N #{@current_resource.path} #{source_path}" )
+          # diff will set a non-zero return code even when there's 
+          # valid stdout results, if it encounters something unexpected
+          # So as long as we have output, we'll show it.
+          if not result.stdout.empty?
+            val = result.stdout.split("\n")
+            val.delete("\")
+            val
+          elsif not result.stderr.empty?
+            "Could not determine diff. Error: #{result.stderr}"
+          else
+            "(no diff)"
+          end
+        rescue Exception => e
+          # Should *not* receive this, but in some circumstances it seems that 
+          # an exception can be thrown even using shell_out instead of shell_out!
+          "Could not determine diff"
+        end
+      end 
+
+      def whyrun_supported?
+        true
+      end
+
       def load_current_resource
         @current_resource = Chef::Resource::File.new(@new_resource.name)
         @new_resource.path.gsub!(/\\/, "/") # for Windows
         @current_resource.path(@new_resource.path)
-        @current_resource
+        if @new_resource.content && ::File.exist?(@new_resource.path)
+          @current_resource.checksum(checksum(@new_resource.path))
+        end
+        setup_acl
+      end
+      
+      def setup_acl
+        @acl_scanner = ScanAccessControl.new(@new_resource, @current_resource)
+        @acl_scanner.set_all!
+      end
+
+      def define_resource_requirements
+        # this must be evaluated before whyrun messages are printed
+        access_controls.requires_changes?
+
+        requirements.assert(:create, :create_if_missing, :touch) do |a|
+          # Make sure the parent dir exists, or else fail.
+          # for why run, print a message explaining the potential error.
+          parent_directory = ::File.dirname(@new_resource.path)
+
+          a.assertion { ::File.directory?(parent_directory) }
+          a.failure_message(Chef::Exceptions::EnclosingDirectoryDoesNotExist, "Parent directory #{parent_directory} does not exist.")
+          a.whyrun("Assuming directory #{parent_directory} would have been created")
+        end
+
+        # Make sure the file is deletable if it exists. Otherwise, fail.
+        requirements.assert(:delete) do |a|
+          a.assertion do
+            if ::File.exists?(@new_resource.path) 
+              ::File.writable?(@new_resource.path)
+            else
+              true
+            end
+          end
+          a.failure_message(Chef::Exceptions::InsufficientPermissions,"File #{@new_resource.path} exists but is not writable so it cannot be deleted")
+        end
       end
 
       # Compare the content of a file.  Returns true if they are the same, false if they are not.
@@ -57,28 +134,46 @@ class Chef
       # Set the content of the file, assuming it is not set correctly already.
       def set_content
         unless compare_content
-          backup @new_resource.path if ::File.exists?(@new_resource.path)
-          ::File.open(@new_resource.path, "w") {|f| f.write @new_resource.content }
-          Chef::Log.info("#{@new_resource} contents updated")
-          @new_resource.updated_by_last_action(true)
+          description = []
+          description << "update content in file #{@new_resource.path} from #{short_cksum(@current_resource.checksum)} to #{short_cksum(new_resource_content_checksum)}"
+          description << diff_current_from_content(@new_resource.content) 
+          converge_by(description) do
+            backup @new_resource.path if ::File.exists?(@new_resource.path)
+            ::File.open(@new_resource.path, "w") {|f| f.write @new_resource.content }
+            Chef::Log.info("#{@new_resource} contents updated")
+          end
         end
       end
 
       def action_create
-        assert_enclosing_directory_exists!
-        unless ::File.exists?(@new_resource.path)
-          ::File.open(@new_resource.path, "w+") {|f| f.write @new_resource.content }
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
+        if !::File.exists?(@new_resource.path)
+          description = []
+          desc = "create new file #{@new_resource.path}"
+          desc << " with content checksum #{short_cksum(new_resource_content_checksum)}" if new_resource.content
+          description << desc
+          description << diff_current_from_content(@new_resource.content) 
+          converge_by(description) do
+            ::File.open(@new_resource.path, "w+") {|f| f.write @new_resource.content }
+            access_controls.set_all
+            Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
+          end
         else
           set_content unless @new_resource.content.nil?
+          set_all_access_controls
+        end
+      end
+
+      def set_all_access_controls
+        if access_controls.requires_changes?
+          converge_by(access_controls.describe_changes) do 
+            access_controls.set_all
+          end
         end
-        enforce_ownership_and_permissions
       end
 
       def action_create_if_missing
         if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
+          Chef::Log.debug("#{@new_resource} exists at #{@new_resource.path} taking no action.")
         else
           action_create
         end
@@ -86,23 +181,21 @@ class Chef
 
       def action_delete
         if ::File.exists?(@new_resource.path)
-          if ::File.writable?(@new_resource.path)
+          converge_by("delete file #{@new_resource.path}") do 
             backup unless ::File.symlink?(@new_resource.path)
             ::File.delete(@new_resource.path)
             Chef::Log.info("#{@new_resource} deleted file at #{@new_resource.path}")
-            @new_resource.updated_by_last_action(true)
-          else
-            raise "Cannot delete #{@new_resource} at #{@new_resource_path}!"
           end
         end
       end
 
       def action_touch
         action_create
-        time = Time.now
-        ::File.utime(time, time, @new_resource.path)
-        Chef::Log.info("#{@new_resource} updated atime and mtime to #{time}")
-        @new_resource.updated_by_last_action(true)
+        converge_by("update utime on file #{@new_resource.path}") do
+          time = Time.now
+          ::File.utime(time, time, @new_resource.path)
+          Chef::Log.info("#{@new_resource} updated atime and mtime to #{time}")
+        end
       end
 
       def backup(file=nil)
@@ -134,16 +227,25 @@ class Chef
         end
       end
 
-      private
+      def deploy_tempfile
+        Tempfile.open(::File.basename(@new_resource.name)) do |tempfile|
+          yield tempfile
 
-      def assert_enclosing_directory_exists!
-        enclosing_dir = ::File.dirname(@new_resource.path)
-        unless ::File.directory?(enclosing_dir)
-          msg = "Cannot create a file at #{@new_resource.path} because the enclosing directory (#{enclosing_dir}) does not exist"
-          raise Chef::Exceptions::EnclosingDirectoryDoesNotExist, msg
+          temp_res = Chef::Resource::CookbookFile.new(@new_resource.name)
+          temp_res.path(tempfile.path)
+          ac = Chef::FileAccessControl.new(temp_res, @new_resource, self)
+          ac.set_all!
+          FileUtils.mv(tempfile.path, @new_resource.path)
         end
       end
 
+      private
+
+      def short_cksum(checksum)
+        return "none" if checksum.nil?
+        checksum.slice(0,6)
+      end
+
       def new_resource_content_checksum
         @new_resource.content && Digest::SHA2.hexdigest(@new_resource.content)
       end