chef 13.12.14-universal-mingw32 → 14.0.190-universal-mingw32

data/lib/chef/provider/mount/aix.rb

@@ -1,6 +1,5 @@
 #
-# Author::
-# Copyright:: Copyright 2009-2016, Chef Software Inc.
+# Copyright:: Copyright 2009-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,7 +21,7 @@ class Chef
   class Provider
     class Mount
       class Aix < Chef::Provider::Mount::Mount
-        provides :mount, platform: %w{aix}
+        provides :mount, platform: "aix"
 
         # Override for aix specific handling
         def initialize(new_resource, run_context)
@@ -41,11 +40,11 @@ class Chef
           enabled = false
 
           regex_arr = device_fstab_regex.split(":")
-          if regex_arr.size.eql?(2)
+          if regex_arr.size == 2
             nodename = regex_arr[0]
-            devicename   = regex_arr[1]
+            devicename = regex_arr[1]
           else
-            devicename   = regex_arr[0]
+            devicename = regex_arr[0]
           end
           # lsfs o/p = #MountPoint:Device:Vfs:Nodename:Type:Size:Options:AutoMount:Acct
           # search only for current mount point
@@ -58,7 +57,7 @@ class Chef
               enabled = true
               @current_resource.fstype($1)
               @current_resource.options($4)
-              Chef::Log.debug("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
+              logger.trace("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
               next
             when /^#{Regexp.escape(@new_resource.mount_point)}:#{nodename}:(\S+)::(\S+)?:(\S+):(\S+):(\S+):(\S+)/
               # mount point entry with hostname or ipv4 address
@@ -66,7 +65,7 @@ class Chef
               @current_resource.fstype($1)
               @current_resource.options($4)
               @current_resource.device("")
-              Chef::Log.debug("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
+              logger.trace("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
               next
             when /^#{Regexp.escape(@new_resource.mount_point)}:(\S+)?:(\S+):#{devicename}:(\S+)?:(\S+):(\S+):(\S+):(\S+)/
               # mount point entry with hostname or ipv4 address
@@ -74,12 +73,12 @@ class Chef
               @current_resource.fstype($2)
               @current_resource.options($5)
               @current_resource.device(devicename + "/")
-              Chef::Log.debug("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
+              logger.trace("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
               next
             when /^#{Regexp.escape(@new_resource.mount_point)}:(.*?):(.*?):(.*?):(.*?):(.*?):(.*?):(.*?):(.*?)/
-              if $3.split("=")[0].eql?("LABEL") || $1.split("=")[0].eql?("LABEL")
+              if $3.split("=")[0] == "LABEL" || $1.split("=")[0] == "LABEL"
                 @current_resource.device_type("label")
-              elsif $3.split("=")[0].eql?("UUID") || $1.split("=")[0].eql?("UUID")
+              elsif $3.split("=")[0] == "UUID" || $1.split("=")[0] == "UUID"
                 @current_resource.device_type("uuid")
               else
                 @current_resource.device_type("device")
@@ -87,10 +86,10 @@ class Chef
 
               if @current_resource.device_type != @new_resource.device_type
                 enabled = true
-                Chef::Log.debug("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
+                logger.trace("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
               else
                 enabled = false
-                Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/filesystems")
+                logger.trace("Found conflicting mount point #{@new_resource.mount_point} in /etc/filesystems")
               end
             end
 
@@ -110,10 +109,10 @@ class Chef
             case line
             when /#{search_device}\s+#{Regexp.escape(@new_resource.mount_point)}/
               mounted = true
-              Chef::Log.debug("Special device #{device_logstring} mounted as #{@new_resource.mount_point}")
+              logger.trace("Special device #{device_logstring} mounted as #{@new_resource.mount_point}")
             when /^[\/\w]+\s+#{Regexp.escape(@new_resource.mount_point)}\s+/
               mounted = false
-              Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/fstab")
+              logger.trace("Found conflicting mount point #{@new_resource.mount_point} in /etc/fstab")
             end
           end
           @current_resource.mounted(mounted)
@@ -138,9 +137,9 @@ class Chef
                        end
             command << " #{@new_resource.mount_point}"
             shell_out!(command)
-            Chef::Log.debug("#{@new_resource} is mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is mounted at #{@new_resource.mount_point}")
           else
-            Chef::Log.debug("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
           end
         end
 
@@ -154,7 +153,7 @@ class Chef
 
         def enable_fs
           if @current_resource.enabled && mount_options_unchanged?
-            Chef::Log.debug("#{@new_resource} is already enabled - nothing to do")
+            logger.trace("#{@new_resource} is already enabled - nothing to do")
             return nil
           end
 
@@ -164,7 +163,7 @@ class Chef
             disable_fs
           end
           ::File.open("/etc/filesystems", "a") do |fstab|
-            fstab.puts("\n\n#{@new_resource.mount_point}:")
+            fstab.puts("#{@new_resource.mount_point}:")
             if network_device?
               device_details = device_fstab.split(":")
               fstab.puts("\tdev\t\t= #{device_details[1]}")
@@ -175,7 +174,7 @@ class Chef
             fstab.puts("\tvfs\t\t= #{@new_resource.fstype}")
             fstab.puts("\tmount\t\t= false")
             fstab.puts "\toptions\t\t= #{@new_resource.options.join(',')}" unless @new_resource.options.nil? || @new_resource.options.empty?
-            Chef::Log.debug("#{@new_resource} is enabled at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is enabled at #{@new_resource.mount_point}")
           end
         end
 
@@ -211,7 +210,7 @@ class Chef
               contents.each { |line| fstab.puts line }
             end
           else
-            Chef::Log.debug("#{@new_resource} is not enabled - nothing to do")
+            logger.trace("#{@new_resource} is not enabled - nothing to do")
           end
         end
 

data/lib/chef/provider/mount/mount.rb

@@ -64,11 +64,11 @@ class Chef
               @current_resource.options($3)
               @current_resource.dump($4.to_i)
               @current_resource.pass($5.to_i)
-              Chef::Log.debug("Found mount #{device_fstab} to #{@new_resource.mount_point} in /etc/fstab")
+              logger.trace("Found mount #{device_fstab} to #{@new_resource.mount_point} in /etc/fstab")
               next
             when /^[\/\w]+\s+#{Regexp.escape(@new_resource.mount_point)}\s+/
               enabled = false
-              Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/fstab")
+              logger.trace("Found conflicting mount point #{@new_resource.mount_point} in /etc/fstab")
             end
           end
           @current_resource.enabled(enabled)
@@ -90,10 +90,10 @@ class Chef
             case line
             when /^#{device_mount_regex}\s+on\s+#{Regexp.escape(real_mount_point)}\s/
               mounted = true
-              Chef::Log.debug("Special device #{device_logstring} mounted as #{real_mount_point}")
+              logger.trace("Special device #{device_logstring} mounted as #{real_mount_point}")
             when /^([\/\w])+\son\s#{Regexp.escape(real_mount_point)}\s+/
               mounted = false
-              Chef::Log.debug("Special device #{$~[1]} mounted as #{real_mount_point}")
+              logger.trace("Special device #{$~[1]} mounted as #{real_mount_point}")
             end
           end
           @current_resource.mounted(mounted)
@@ -114,18 +114,18 @@ class Chef
                        end
             command << " #{@new_resource.mount_point}"
             shell_out!(command)
-            Chef::Log.debug("#{@new_resource} is mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is mounted at #{@new_resource.mount_point}")
           else
-            Chef::Log.debug("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
           end
         end
 
         def umount_fs
           if @current_resource.mounted
             shell_out!("umount #{@new_resource.mount_point}")
-            Chef::Log.debug("#{@new_resource} is no longer mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is no longer mounted at #{@new_resource.mount_point}")
           else
-            Chef::Log.debug("#{@new_resource} is not mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is not mounted at #{@new_resource.mount_point}")
           end
         end
 
@@ -137,19 +137,24 @@ class Chef
           if @current_resource.mounted && @new_resource.supports[:remount]
             shell_out!(remount_command)
             @new_resource.updated_by_last_action(true)
-            Chef::Log.debug("#{@new_resource} is remounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is remounted at #{@new_resource.mount_point}")
           elsif @current_resource.mounted
             umount_fs
             sleep 1
             mount_fs
           else
-            Chef::Log.debug("#{@new_resource} is not mounted at #{@new_resource.mount_point} - nothing to do")
+            logger.trace("#{@new_resource} is not mounted at #{@new_resource.mount_point} - nothing to do")
           end
         end
 
+        # Return appropriate default mount options according to the given os.
+        def default_mount_options
+          node[:os] == "linux" ? "defaults" : "rw"
+        end
+
         def enable_fs
           if @current_resource.enabled && mount_options_unchanged? && device_unchanged?
-            Chef::Log.debug("#{@new_resource} is already enabled - nothing to do")
+            logger.trace("#{@new_resource} is already enabled - nothing to do")
             return nil
           end
 
@@ -159,8 +164,8 @@ class Chef
             disable_fs
           end
           ::File.open("/etc/fstab", "a") do |fstab|
-            fstab.puts("#{device_fstab} #{@new_resource.mount_point} #{@new_resource.fstype} #{@new_resource.options.nil? ? "defaults" : @new_resource.options.join(",")} #{@new_resource.dump} #{@new_resource.pass}")
-            Chef::Log.debug("#{@new_resource} is enabled at #{@new_resource.mount_point}")
+            fstab.puts("#{device_fstab} #{@new_resource.mount_point} #{@new_resource.fstype} #{@new_resource.options.nil? ? default_mount_options : @new_resource.options.join(",")} #{@new_resource.dump} #{@new_resource.pass}")
+            logger.trace("#{@new_resource} is enabled at #{@new_resource.mount_point}")
           end
         end
 
@@ -172,7 +177,7 @@ class Chef
             ::File.readlines("/etc/fstab").reverse_each do |line|
               if !found && line =~ /^#{device_fstab_regex}\s+#{Regexp.escape(@new_resource.mount_point)}\s/
                 found = true
-                Chef::Log.debug("#{@new_resource} is removed from fstab")
+                logger.trace("#{@new_resource} is removed from fstab")
                 next
               else
                 contents << line
@@ -183,7 +188,7 @@ class Chef
               contents.reverse_each { |line| fstab.puts line }
             end
           else
-            Chef::Log.debug("#{@new_resource} is not enabled - nothing to do")
+            logger.trace("#{@new_resource} is not enabled - nothing to do")
           end
         end
 

data/lib/chef/provider/mount/solaris.rb

@@ -112,7 +112,7 @@ class Chef
           else
             # this is likely some kind of internal error, since we should only call disable_fs when there
             # the filesystem we want to disable is enabled.
-            Chef::Log.warn("#{new_resource} did not find the mountpoint to disable in the vfstab")
+            logger.warn("#{new_resource} did not find the mountpoint to disable in the vfstab")
           end
         end
 
@@ -153,10 +153,10 @@ class Chef
           shell_out!("mount -v").stdout.each_line do |line|
             case line
             when /^#{device_regex}\s+on\s+#{Regexp.escape(mount_point)}\s+/
-              Chef::Log.debug("Special device #{device} is mounted as #{mount_point}")
+              logger.trace("Special device #{device} is mounted as #{mount_point}")
               mounted = true
             when /^([\/\w]+)\son\s#{Regexp.escape(mount_point)}\s+/
-              Chef::Log.debug("Special device #{Regexp.last_match[1]} is mounted as #{mount_point}")
+              logger.trace("Special device #{Regexp.last_match[1]} is mounted as #{mount_point}")
               mounted = false
             end
           end
@@ -191,12 +191,12 @@ class Chef
                 end
               end
               pass = (Regexp.last_match[2] == "-") ? 0 : Regexp.last_match[2].to_i
-              Chef::Log.debug("Found mount #{device} to #{mount_point} in #{VFSTAB}")
+              logger.trace("Found mount #{device} to #{mount_point} in #{VFSTAB}")
               next
             when /^[-\/\w]+\s+[-\/\w]+\s+#{Regexp.escape(mount_point)}\s+/
               # if we find a mountpoint on top of our mountpoint, then we are not enabled
               enabled = false
-              Chef::Log.debug("Found conflicting mount point #{mount_point} in #{VFSTAB}")
+              logger.trace("Found conflicting mount point #{mount_point} in #{VFSTAB}")
             end
           end
           [enabled, fstype, options, pass]
@@ -234,7 +234,7 @@ class Chef
           ::File.readlines(VFSTAB).reverse_each do |line|
             if !found && line =~ /^#{device_regex}\s+\S+\s+#{Regexp.escape(mount_point)}/
               found = true
-              Chef::Log.debug("#{new_resource} is removed from vfstab")
+              logger.trace("#{new_resource} is removed from vfstab")
               next
             end
             contents << line

data/lib/chef/provider/mount/windows.rb

@@ -47,15 +47,15 @@ class Chef
 
           @current_resource = Chef::Resource::Mount.new(@new_resource.name)
           @current_resource.mount_point(@new_resource.mount_point)
-          Chef::Log.debug("Checking for mount point #{@current_resource.mount_point}")
+          logger.trace("Checking for mount point #{@current_resource.mount_point}")
 
           begin
             @current_resource.device(@mount.device)
-            Chef::Log.debug("#{@current_resource.device} mounted on #{@new_resource.mount_point}")
+            logger.trace("#{@current_resource.device} mounted on #{@new_resource.mount_point}")
             @current_resource.mounted(true)
           rescue ArgumentError => e
             @current_resource.mounted(false)
-            Chef::Log.debug("#{@new_resource.mount_point} is not mounted: #{e.message}")
+            logger.trace("#{@new_resource.mount_point} is not mounted: #{e.message}")
           end
         end
 
@@ -65,18 +65,18 @@ class Chef
                        :username => @new_resource.username,
                        :domainname => @new_resource.domain,
                        :password => @new_resource.password)
-            Chef::Log.debug("#{@new_resource} is mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is mounted at #{@new_resource.mount_point}")
           else
-            Chef::Log.debug("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
           end
         end
 
         def umount_fs
           if @current_resource.mounted
             @mount.delete
-            Chef::Log.debug("#{@new_resource} is no longer mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is no longer mounted at #{@new_resource.mount_point}")
           else
-            Chef::Log.debug("#{@new_resource} is not mounted at #{@new_resource.mount_point}")
+            logger.trace("#{@new_resource} is not mounted at #{@new_resource.mount_point}")
           end
         end
 

data/lib/chef/provider/noop.rb

@@ -27,7 +27,7 @@ class Chef
 
       def method_missing(method_sym, *arguments, &block)
         if method_sym.to_s =~ /^action_/
-          Chef::Log.debug("NoOp-ing for #{method_sym}")
+          logger.trace("NoOp-ing for #{method_sym}")
         else
           super
         end

data/lib/chef/provider/ohai.rb

@@ -37,7 +37,7 @@ class Chef
           # the path are picked up by ohai.
           ohai.all_plugins new_resource.plugin
           node.automatic_attrs.merge! ohai.data
-          Chef::Log.info("#{new_resource} reloaded")
+          logger.info("#{new_resource} reloaded")
         end
       end
     end

data/lib/chef/provider/osx_profile.rb

@@ -25,8 +25,8 @@ require "uuidtools"
 class Chef
   class Provider
     class OsxProfile < Chef::Provider
-      provides :osx_profile, os: "darwin"
-      provides :osx_config_profile, os: "darwin"
+      provides :osx_profile
+      provides :osx_config_profile
 
       def load_current_resource
         @current_resource = Chef::Resource::OsxProfile.new(new_resource.name)
@@ -188,15 +188,15 @@ class Chef
       end
 
       def install_profile(profile_path)
-        cmd = "/usr/bin/profiles -I -F '#{profile_path}'"
-        Chef::Log.debug("cmd: #{cmd}")
+        cmd = "profiles -I -F '#{profile_path}'"
+        logger.trace("cmd: #{cmd}")
         shellout_results = shell_out(cmd)
         shellout_results.exitstatus
       end
 
       def remove_profile
-        cmd = "/usr/bin/profiles -R -p '#{@new_profile_identifier}'"
-        Chef::Log.debug("cmd: #{cmd}")
+        cmd = "profiles -R -p '#{@new_profile_identifier}'"
+        logger.trace("cmd: #{cmd}")
         shellout_results = shell_out(cmd)
         shellout_results.exitstatus
       end
@@ -214,7 +214,7 @@ class Chef
         tempfile = generate_tempfile
         write_installed_profiles(tempfile)
         installed_profiles = read_plist(tempfile)
-        Chef::Log.debug("Saved profiles to run_state")
+        logger.trace("Saved profiles to run_state")
         # Clean up the temp file as we do not need it anymore
         ::File.unlink(tempfile)
         installed_profiles
@@ -225,7 +225,7 @@ class Chef
       end
 
       def write_installed_profiles(tempfile)
-        cmd = "/usr/bin/profiles -P -o '#{tempfile}'"
+        cmd = "profiles -P -o '#{tempfile}'"
         shell_out!(cmd)
       end
 

data/lib/chef/provider/package.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -84,7 +84,7 @@ class Chef
 
       action :install do
         unless target_version_array.any?
-          Chef::Log.debug("#{new_resource} is already installed - nothing to do")
+          logger.trace("#{new_resource} is already installed - nothing to do")
           return
         end
 
@@ -101,7 +101,7 @@ class Chef
           multipackage_api_adapter(package_names_for_targets, versions_for_targets) do |name, version|
             install_package(name, version)
           end
-          Chef::Log.info("#{new_resource} installed #{package_names_for_targets} at #{versions_for_targets}")
+          logger.info("#{new_resource} installed #{package_names_for_targets} at #{versions_for_targets}")
         end
       end
 
@@ -119,7 +119,7 @@ class Chef
 
       action :upgrade do
         unless target_version_array.any?
-          Chef::Log.debug("#{new_resource} no versions to upgrade - nothing to do")
+          logger.trace("#{new_resource} no versions to upgrade - nothing to do")
           return
         end
 
@@ -128,7 +128,7 @@ class Chef
             upgrade_package(name, version)
           end
           log_allow_downgrade = allow_downgrade ? "(allow_downgrade)" : ""
-          Chef::Log.info("#{new_resource} upgraded#{log_allow_downgrade} #{package_names_for_targets} to #{versions_for_targets}")
+          logger.info("#{new_resource} upgraded#{log_allow_downgrade} #{package_names_for_targets} to #{versions_for_targets}")
         end
       end
 
@@ -154,10 +154,10 @@ class Chef
             multipackage_api_adapter(current_resource.package_name, new_resource.version) do |name, version|
               remove_package(name, version)
             end
-            Chef::Log.info("#{new_resource} removed")
+            logger.info("#{new_resource} removed")
           end
         else
-          Chef::Log.debug("#{new_resource} package does not exist - nothing to do")
+          logger.trace("#{new_resource} package does not exist - nothing to do")
         end
       end
 
@@ -189,19 +189,19 @@ class Chef
             multipackage_api_adapter(current_resource.package_name, new_resource.version) do |name, version|
               purge_package(name, version)
             end
-            Chef::Log.info("#{new_resource} purged")
+            logger.info("#{new_resource} purged")
           end
         end
       end
 
       action :reconfig do
         if current_resource.version.nil?
-          Chef::Log.debug("#{new_resource} is NOT installed - nothing to do")
+          logger.trace("#{new_resource} is NOT installed - nothing to do")
           return
         end
 
         unless new_resource.response_file
-          Chef::Log.debug("#{new_resource} no response_file provided - nothing to do")
+          logger.trace("#{new_resource} no response_file provided - nothing to do")
           return
         end
 
@@ -212,41 +212,52 @@ class Chef
               reconfig_package(name, version)
 
             end
-            Chef::Log.info("#{new_resource} reconfigured")
+            logger.info("#{new_resource} reconfigured")
           end
         else
-          Chef::Log.debug("#{new_resource} preseeding has not changed - nothing to do")
+          logger.trace("#{new_resource} preseeding has not changed - nothing to do")
         end
       end
 
       def action_lock
-        if package_locked(new_resource.name, new_resource.version) == false
+        packages_locked = if respond_to?(:packages_all_locked?, true)
+                            packages_all_locked?(Array(new_resource.package_name), Array(new_resource.version))
+                          else
+                            package_locked(new_resource.package_name, new_resource.version)
+                          end
+        unless packages_locked
           description = new_resource.version ? "version #{new_resource.version} of " : ""
           converge_by("lock #{description}package #{current_resource.package_name}") do
             multipackage_api_adapter(current_resource.package_name, new_resource.version) do |name, version|
               lock_package(name, version)
-              Chef::Log.info("#{new_resource} locked")
+              logger.info("#{new_resource} locked")
             end
           end
         else
-          Chef::Log.debug("#{new_resource} is already locked")
+          logger.trace("#{new_resource} is already locked")
         end
       end
 
       def action_unlock
-        if package_locked(new_resource.name, new_resource.version) == true
+        packages_unlocked = if respond_to?(:packages_all_unlocked?, true)
+                              packages_all_unlocked?(Array(new_resource.package_name), Array(new_resource.version))
+                            else
+                              !package_locked(new_resource.package_name, new_resource.version)
+                            end
+        unless packages_unlocked
           description = new_resource.version ? "version #{new_resource.version} of " : ""
           converge_by("unlock #{description}package #{current_resource.package_name}") do
             multipackage_api_adapter(current_resource.package_name, new_resource.version) do |name, version|
               unlock_package(name, version)
-              Chef::Log.info("#{new_resource} unlocked")
+              logger.info("#{new_resource} unlocked")
             end
           end
         else
-          Chef::Log.debug("#{new_resource} is already unlocked")
+          logger.trace("#{new_resource} is already unlocked")
         end
       end
 
+      # for multipackage just implement packages_all_[un]locked? properly and omit implementing this API
       def package_locked(name, version)
         raise Chef::Exceptions::UnsupportedAction, "#{self} has no way to detect if package is locked"
       end
@@ -372,7 +383,7 @@ class Chef
       def get_preseed_file(name, version)
         resource = preseed_resource(name, version)
         resource.run_action(:create)
-        Chef::Log.debug("#{new_resource} fetched preseed file to #{resource.path}")
+        logger.trace("#{new_resource} fetched preseed file to #{resource.path}")
 
         if resource.updated_by_last_action?
           resource.path
@@ -388,14 +399,14 @@ class Chef
         # The full path where the preseed file will be stored
         cache_seed_to = "#{file_cache_dir}/#{name}-#{version}.seed"
 
-        Chef::Log.debug("#{new_resource} fetching preseed file to #{cache_seed_to}")
+        logger.trace("#{new_resource} fetching preseed file to #{cache_seed_to}")
 
         if template_available?(new_resource.response_file)
-          Chef::Log.debug("#{new_resource} fetching preseed file via Template")
+          logger.trace("#{new_resource} fetching preseed file via Template")
           remote_file = Chef::Resource::Template.new(cache_seed_to, run_context)
           remote_file.variables(new_resource.response_file_variables)
         elsif cookbook_file_available?(new_resource.response_file)
-          Chef::Log.debug("#{new_resource} fetching preseed file via cookbook_file")
+          logger.trace("#{new_resource} fetching preseed file via cookbook_file")
           remote_file = Chef::Resource::CookbookFile.new(cache_seed_to, run_context)
         else
           message = "No template or cookbook file found for response file #{new_resource.response_file}"
@@ -469,22 +480,22 @@ class Chef
               when :upgrade
                 if version_equals?(current_version, new_version)
                   # this is an odd use case
-                  Chef::Log.debug("#{new_resource} #{package_name} #{new_version} is already installed -- you are equality pinning with an :upgrade action, this may be deprecated in the future")
+                  logger.trace("#{new_resource} #{package_name} #{new_version} is already installed -- you are equality pinning with an :upgrade action, this may be deprecated in the future")
                   target_version_array.push(nil)
                 elsif version_equals?(current_version, candidate_version)
-                  Chef::Log.debug("#{new_resource} #{package_name} #{candidate_version} is already installed")
+                  logger.trace("#{new_resource} #{package_name} #{candidate_version} is already installed")
                   target_version_array.push(nil)
                 elsif candidate_version.nil?
-                  Chef::Log.debug("#{new_resource} #{package_name} has no candidate_version to upgrade to")
+                  logger.trace("#{new_resource} #{package_name} has no candidate_version to upgrade to")
                   target_version_array.push(nil)
                 elsif current_version.nil?
-                  Chef::Log.debug("#{new_resource} has no existing installed version. Installing install #{candidate_version}")
+                  logger.trace("#{new_resource} has no existing installed version. Installing install #{candidate_version}")
                   target_version_array.push(candidate_version)
                 elsif version_compare(current_version, candidate_version) == 1 && !allow_downgrade
-                  Chef::Log.debug("#{new_resource} #{package_name} has installed version #{current_version}, which is newer than available version #{candidate_version}. Skipping...)")
+                  logger.trace("#{new_resource} #{package_name} has installed version #{current_version}, which is newer than available version #{candidate_version}. Skipping...)")
                   target_version_array.push(nil)
                 else
-                  Chef::Log.debug("#{new_resource} #{package_name} is out of date, will upgrade to #{candidate_version}")
+                  logger.trace("#{new_resource} #{package_name} is out of date, will upgrade to #{candidate_version}")
                   target_version_array.push(candidate_version)
                 end
 
@@ -492,17 +503,17 @@ class Chef
 
                 if new_version
                   if version_requirement_satisfied?(current_version, new_version)
-                    Chef::Log.debug("#{new_resource} #{package_name} #{current_version} satisifies #{new_version} requirement")
+                    logger.trace("#{new_resource} #{package_name} #{current_version} satisifies #{new_version} requirement")
                     target_version_array.push(nil)
                   else
-                    Chef::Log.debug("#{new_resource} #{package_name} #{current_version} needs updating to #{new_version}")
+                    logger.trace("#{new_resource} #{package_name} #{current_version} needs updating to #{new_version}")
                     target_version_array.push(new_version)
                   end
                 elsif current_version.nil?
-                  Chef::Log.debug("#{new_resource} #{package_name} not installed, installing #{candidate_version}")
+                  logger.trace("#{new_resource} #{package_name} not installed, installing #{candidate_version}")
                   target_version_array.push(candidate_version)
                 else
-                  Chef::Log.debug("#{new_resource} #{package_name} #{current_version} already installed")
+                  logger.trace("#{new_resource} #{package_name} #{current_version} already installed")
                   target_version_array.push(nil)
                 end
 
@@ -580,12 +591,12 @@ class Chef
 
       # @return [Boolean] if we're doing a multipackage install or not
       def multipackage?
-        new_resource.package_name.is_a?(Array)
+        @multipackage_bool ||= new_resource.package_name.is_a?(Array)
       end
 
       # @return [Array] package_name(s) as an array
       def package_name_array
-        [ new_resource.package_name ].flatten
+        @package_name_array ||= [ new_resource.package_name ].flatten
       end
 
       # @return [Array] candidate_version(s) as an array
@@ -597,12 +608,12 @@ class Chef
 
       # @return [Array] current_version(s) as an array
       def current_version_array
-        [ current_resource.version ].flatten
+        @current_version_array ||= [ current_resource.version ].flatten
       end
 
       # @return [Array] new_version(s) as an array
       def new_version_array
-        [ new_resource.version ].flatten.map { |v| v.to_s.empty? ? nil : v }
+        @new_version_array ||= [ new_resource.version ].flatten.map { |v| v.to_s.empty? ? nil : v }
       end
 
       # TIP: less error prone to simply always call resolved_source_array, even if you
@@ -610,11 +621,14 @@ class Chef
       #
       # @return [Array] new_resource.source as an array
       def source_array
-        if new_resource.source.nil?
-          package_name_array.map { nil }
-        else
-          [ new_resource.source ].flatten
-        end
+        @source_array ||=
+          begin
+            if new_resource.source.nil?
+              package_name_array.map { nil }
+            else
+              [ new_resource.source ].flatten
+            end
+          end
       end
 
       # Helper to handle use_package_name_for_source to convert names into local packages to install.
@@ -627,7 +641,7 @@ class Chef
               package_name = package_name_array[i]
               # we require at least one '/' in the package_name to avoid [XXX_]package 'foo' breaking due to a random 'foo' file in cwd
               if use_package_name_for_source? && source.nil? && package_name.match(/#{::File::SEPARATOR}/) && ::File.exist?(package_name)
-                Chef::Log.debug("No package source specified, but #{package_name} exists on filesystem, using #{package_name} as source.")
+                logger.trace("No package source specified, but #{package_name} exists on filesystem, using #{package_name} as source.")
                 package_name
               else
                 source