chef 12.18.31 → 12.19.33

data/lib/chef/provider/http_request.rb

@@ -32,78 +32,78 @@ class Chef
       end
 
       def load_current_resource
-        @http = Chef::HTTP::Simple.new(@new_resource.url)
+        @http = Chef::HTTP::Simple.new(new_resource.url)
       end
 
-      # Send a HEAD request to @new_resource.url
+      # Send a HEAD request to new_resource.url
       def action_head
-        message = check_message(@new_resource.message)
+        message = check_message(new_resource.message)
         # CHEF-4762: we expect a nil return value from Chef::HTTP for a "200 Success" response
         # and false for a "304 Not Modified" response
         modified = @http.head(
-          "#{@new_resource.url}",
-          @new_resource.headers
+          "#{new_resource.url}",
+          new_resource.headers
         )
-        Chef::Log.info("#{@new_resource} HEAD to #{@new_resource.url} successful")
-        Chef::Log.debug("#{@new_resource} HEAD request response: #{modified}")
+        Chef::Log.info("#{new_resource} HEAD to #{new_resource.url} successful")
+        Chef::Log.debug("#{new_resource} HEAD request response: #{modified}")
         # :head is usually used to trigger notifications, which converge_by now does
         if modified != false
-          converge_by("#{@new_resource} HEAD to #{@new_resource.url} returned modified, trigger notifications") {}
+          converge_by("#{new_resource} HEAD to #{new_resource.url} returned modified, trigger notifications") {}
         end
       end
 
-      # Send a GET request to @new_resource.url
+      # Send a GET request to new_resource.url
       def action_get
-        converge_by("#{@new_resource} GET to #{@new_resource.url}") do
+        converge_by("#{new_resource} GET to #{new_resource.url}") do
 
-          message = check_message(@new_resource.message)
+          message = check_message(new_resource.message)
           body = @http.get(
-            "#{@new_resource.url}",
-            @new_resource.headers
+            "#{new_resource.url}",
+            new_resource.headers
           )
-          Chef::Log.info("#{@new_resource} GET to #{@new_resource.url} successful")
-          Chef::Log.debug("#{@new_resource} GET request response: #{body}")
+          Chef::Log.info("#{new_resource} GET to #{new_resource.url} successful")
+          Chef::Log.debug("#{new_resource} GET request response: #{body}")
         end
       end
 
-      # Send a PUT request to @new_resource.url, with the message as the payload
+      # Send a PUT request to new_resource.url, with the message as the payload
       def action_put
-        converge_by("#{@new_resource} PUT to #{@new_resource.url}") do
-          message = check_message(@new_resource.message)
+        converge_by("#{new_resource} PUT to #{new_resource.url}") do
+          message = check_message(new_resource.message)
           body = @http.put(
-            "#{@new_resource.url}",
+            "#{new_resource.url}",
             message,
-            @new_resource.headers
+            new_resource.headers
           )
-          Chef::Log.info("#{@new_resource} PUT to #{@new_resource.url} successful")
-          Chef::Log.debug("#{@new_resource} PUT request response: #{body}")
+          Chef::Log.info("#{new_resource} PUT to #{new_resource.url} successful")
+          Chef::Log.debug("#{new_resource} PUT request response: #{body}")
         end
       end
 
-      # Send a POST request to @new_resource.url, with the message as the payload
+      # Send a POST request to new_resource.url, with the message as the payload
       def action_post
-        converge_by("#{@new_resource} POST to #{@new_resource.url}") do
-          message = check_message(@new_resource.message)
+        converge_by("#{new_resource} POST to #{new_resource.url}") do
+          message = check_message(new_resource.message)
           body = @http.post(
-            "#{@new_resource.url}",
+            "#{new_resource.url}",
             message,
-            @new_resource.headers
+            new_resource.headers
           )
-          Chef::Log.info("#{@new_resource} POST to #{@new_resource.url} message: #{message.inspect} successful")
-          Chef::Log.debug("#{@new_resource} POST request response: #{body}")
+          Chef::Log.info("#{new_resource} POST to #{new_resource.url} message: #{message.inspect} successful")
+          Chef::Log.debug("#{new_resource} POST request response: #{body}")
         end
       end
 
-      # Send a DELETE request to @new_resource.url
+      # Send a DELETE request to new_resource.url
       def action_delete
-        converge_by("#{@new_resource} DELETE to #{@new_resource.url}") do
+        converge_by("#{new_resource} DELETE to #{new_resource.url}") do
           body = @http.delete(
-            "#{@new_resource.url}",
-            @new_resource.headers
+            "#{new_resource.url}",
+            new_resource.headers
           )
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} DELETE to #{@new_resource.url} successful")
-          Chef::Log.debug("#{@new_resource} DELETE request response: #{body}")
+          new_resource.updated_by_last_action(true)
+          Chef::Log.info("#{new_resource} DELETE to #{new_resource.url} successful")
+          Chef::Log.debug("#{new_resource} DELETE request response: #{body}")
         end
       end
 

data/lib/chef/provider/launchd.rb

@@ -30,7 +30,7 @@ class Chef
       extend Forwardable
       provides :launchd, os: "darwin"
 
-      def_delegators :@new_resource, *[
+      def_delegators :new_resource, *[
         :backup,
         :cookbook,
         :group,
@@ -150,7 +150,7 @@ class Chef
       end
 
       def content
-        plist_hash = new_resource.hash || gen_hash
+        plist_hash = new_resource.plist_hash || gen_hash
         Plist::Emit.dump(plist_hash) unless plist_hash.nil?
       end
 

data/lib/chef/provider/link.rb

@@ -47,41 +47,41 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::Link.new(@new_resource.name)
-        @current_resource.target_file(@new_resource.target_file)
-        if file_class.symlink?(@current_resource.target_file)
-          @current_resource.link_type(:symbolic)
-          @current_resource.to(
-            canonicalize(file_class.readlink(@current_resource.target_file))
+        @current_resource = Chef::Resource::Link.new(new_resource.name)
+        current_resource.target_file(new_resource.target_file)
+        if file_class.symlink?(current_resource.target_file)
+          current_resource.link_type(:symbolic)
+          current_resource.to(
+            canonicalize(file_class.readlink(current_resource.target_file))
           )
         else
-          @current_resource.link_type(:hard)
-          if ::File.exists?(@current_resource.target_file)
-            if ::File.exists?(@new_resource.to) &&
-                file_class.stat(@current_resource.target_file).ino ==
-                    file_class.stat(@new_resource.to).ino
-              @current_resource.to(canonicalize(@new_resource.to))
+          current_resource.link_type(:hard)
+          if ::File.exists?(current_resource.target_file)
+            if ::File.exists?(new_resource.to) &&
+                file_class.stat(current_resource.target_file).ino ==
+                    file_class.stat(new_resource.to).ino
+              current_resource.to(canonicalize(new_resource.to))
             else
-              @current_resource.to("")
+              current_resource.to("")
             end
           end
         end
-        ScanAccessControl.new(@new_resource, @current_resource).set_all!
-        @current_resource
+        ScanAccessControl.new(new_resource, current_resource).set_all!
+        current_resource
       end
 
       def define_resource_requirements
         requirements.assert(:delete) do |a|
           a.assertion do
-            if @current_resource.to
-              @current_resource.link_type == @new_resource.link_type &&
-                (@current_resource.link_type == :symbolic || @current_resource.to != "")
+            if current_resource.to
+              current_resource.link_type == new_resource.link_type &&
+                (current_resource.link_type == :symbolic || current_resource.to != "")
             else
               true
             end
           end
-          a.failure_message Chef::Exceptions::Link, "Cannot delete #{@new_resource} at #{@new_resource.target_file}! Not a #{@new_resource.link_type} link."
-          a.whyrun("Would assume the link at #{@new_resource.target_file} was previously created")
+          a.failure_message Chef::Exceptions::Link, "Cannot delete #{new_resource} at #{new_resource.target_file}! Not a #{new_resource.link_type} link."
+          a.whyrun("Would assume the link at #{new_resource.target_file} was previously created")
         end
       end
 
@@ -95,48 +95,48 @@ class Chef
         #   to - the location to link to
         #   target_file - the name of the link
 
-        if @current_resource.to != canonicalize(@new_resource.to) ||
-            @current_resource.link_type != @new_resource.link_type
+        if current_resource.to != canonicalize(new_resource.to) ||
+            current_resource.link_type != new_resource.link_type
           # Handle the case where the symlink already exists and is pointing at a valid to_file
-          if @current_resource.to
+          if current_resource.to
             # On Windows, to fix a symlink already pointing at a directory we must first
             # ::Dir.unlink the symlink (not the directory), while if we have a symlink
             # pointing at file we must use ::File.unlink on the symlink.
             # However if the new symlink will point to a file and the current symlink is pointing at a
             # directory we want to throw an exception and calling ::File.unlink on the directory symlink
             # will throw the correct ones.
-            if Chef::Platform.windows? && ::File.directory?(@new_resource.to) &&
-                ::File.directory?(@current_resource.target_file)
-              converge_by("unlink existing windows symlink to dir at #{@new_resource.target_file}") do
-                ::Dir.unlink(@new_resource.target_file)
+            if Chef::Platform.windows? && ::File.directory?(new_resource.to) &&
+                ::File.directory?(current_resource.target_file)
+              converge_by("unlink existing windows symlink to dir at #{new_resource.target_file}") do
+                ::Dir.unlink(new_resource.target_file)
               end
             else
-              converge_by("unlink existing symlink to file at #{@new_resource.target_file}") do
-                ::File.unlink(@new_resource.target_file)
+              converge_by("unlink existing symlink to file at #{new_resource.target_file}") do
+                ::File.unlink(new_resource.target_file)
               end
             end
           end
-          if @new_resource.link_type == :symbolic
-            converge_by("create symlink at #{@new_resource.target_file} to #{@new_resource.to}") do
-              file_class.symlink(canonicalize(@new_resource.to), @new_resource.target_file)
-              Chef::Log.debug("#{@new_resource} created #{@new_resource.link_type} link from #{@new_resource.target_file} -> #{@new_resource.to}")
-              Chef::Log.info("#{@new_resource} created")
+          if new_resource.link_type == :symbolic
+            converge_by("create symlink at #{new_resource.target_file} to #{new_resource.to}") do
+              file_class.symlink(canonicalize(new_resource.to), new_resource.target_file)
+              Chef::Log.debug("#{new_resource} created #{new_resource.link_type} link from #{new_resource.target_file} -> #{new_resource.to}")
+              Chef::Log.info("#{new_resource} created")
               # file_class.symlink will create the link with default access controls.
               # This means that the access controls of the file could be different
               # than those captured during the initial evaluation of current_resource.
               # We need to re-evaluate the current_resource to ensure that the desired
               # access controls are applied.
-              ScanAccessControl.new(@new_resource, @current_resource).set_all!
+              ScanAccessControl.new(new_resource, current_resource).set_all!
             end
-          elsif @new_resource.link_type == :hard
-            converge_by("create hard link at #{@new_resource.target_file} to #{@new_resource.to}") do
-              file_class.link(@new_resource.to, @new_resource.target_file)
-              Chef::Log.debug("#{@new_resource} created #{@new_resource.link_type} link from #{@new_resource.target_file} -> #{@new_resource.to}")
-              Chef::Log.info("#{@new_resource} created")
+          elsif new_resource.link_type == :hard
+            converge_by("create hard link at #{new_resource.target_file} to #{new_resource.to}") do
+              file_class.link(new_resource.to, new_resource.target_file)
+              Chef::Log.debug("#{new_resource} created #{new_resource.link_type} link from #{new_resource.target_file} -> #{new_resource.to}")
+              Chef::Log.info("#{new_resource} created")
             end
           end
         end
-        if @new_resource.link_type == :symbolic
+        if new_resource.link_type == :symbolic
           if access_controls.requires_changes?
             converge_by(access_controls.describe_changes) do
               access_controls.set_all
@@ -146,16 +146,16 @@ class Chef
       end
 
       def action_delete
-        if @current_resource.to # Exists
-          if Chef::Platform.windows? && ::File.directory?(@current_resource.target_file)
-            converge_by("delete link to dir at #{@new_resource.target_file}") do
-              ::Dir.delete(@new_resource.target_file)
-              Chef::Log.info("#{@new_resource} deleted")
+        if current_resource.to # Exists
+          if Chef::Platform.windows? && ::File.directory?(current_resource.target_file)
+            converge_by("delete link to dir at #{new_resource.target_file}") do
+              ::Dir.delete(new_resource.target_file)
+              Chef::Log.info("#{new_resource} deleted")
             end
           else
-            converge_by("delete link to file at #{@new_resource.target_file}") do
-              ::File.delete(@new_resource.target_file)
-              Chef::Log.info("#{@new_resource} deleted")
+            converge_by("delete link to file at #{new_resource.target_file}") do
+              ::File.delete(new_resource.target_file)
+              Chef::Log.info("#{new_resource} deleted")
             end
           end
         end
@@ -165,7 +165,7 @@ class Chef
       # access control (e.g., use lchmod instead of chmod) if the resource is a
       # symlink.
       def manage_symlink_access?
-        @new_resource.link_type == :symbolic
+        new_resource.link_type == :symbolic
       end
     end
   end

data/lib/chef/provider/log.rb

@@ -44,8 +44,8 @@ class Chef
         # === Return
         # true:: Always return true
         def action_write
-          Chef::Log.send(@new_resource.level, @new_resource.message)
-          @new_resource.updated_by_last_action(true) if Chef::Config[:count_log_resource_updates]
+          Chef::Log.send(new_resource.level, new_resource.message)
+          new_resource.updated_by_last_action(true) if Chef::Config[:count_log_resource_updates]
         end
 
       end

data/lib/chef/provider/mdadm.rb

@@ -34,57 +34,57 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::Mdadm.new(@new_resource.name)
-        @current_resource.raid_device(@new_resource.raid_device)
-        Chef::Log.debug("#{@new_resource} checking for software raid device #{@current_resource.raid_device}")
+        @current_resource = Chef::Resource::Mdadm.new(new_resource.name)
+        current_resource.raid_device(new_resource.raid_device)
+        Chef::Log.debug("#{new_resource} checking for software raid device #{current_resource.raid_device}")
 
         device_not_found = 4
-        mdadm = shell_out!("mdadm --detail --test #{@new_resource.raid_device}", :returns => [0, device_not_found])
+        mdadm = shell_out!("mdadm --detail --test #{new_resource.raid_device}", :returns => [0, device_not_found])
         exists = (mdadm.status == 0)
-        @current_resource.exists(exists)
+        current_resource.exists(exists)
       end
 
       def action_create
-        unless @current_resource.exists
+        unless current_resource.exists
           converge_by("create RAID device #{new_resource.raid_device}") do
-            command = "yes | mdadm --create #{@new_resource.raid_device} --level #{@new_resource.level}"
-            command << " --chunk=#{@new_resource.chunk}" unless @new_resource.level == 1
-            command << " --metadata=#{@new_resource.metadata}"
-            command << " --bitmap=#{@new_resource.bitmap}" if @new_resource.bitmap
-            command << " --layout=#{@new_resource.layout}" if @new_resource.layout
-            command << " --raid-devices #{@new_resource.devices.length} #{@new_resource.devices.join(" ")}"
-            Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
+            command = "yes | mdadm --create #{new_resource.raid_device} --level #{new_resource.level}"
+            command << " --chunk=#{new_resource.chunk}" unless new_resource.level == 1
+            command << " --metadata=#{new_resource.metadata}"
+            command << " --bitmap=#{new_resource.bitmap}" if new_resource.bitmap
+            command << " --layout=#{new_resource.layout}" if new_resource.layout
+            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})")
+            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})")
+          Chef::Log.debug("#{new_resource} raid device already exists, skipping create (#{new_resource.raid_device})")
         end
       end
 
       def action_assemble
-        unless @current_resource.exists
+        unless current_resource.exists
           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}")
+            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})")
+            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})")
+          Chef::Log.debug("#{new_resource} raid device already exists, skipping assemble (#{new_resource.raid_device})")
         end
       end
 
       def action_stop
-        if @current_resource.exists
+        if current_resource.exists
           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}")
+            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})")
+            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")
+          Chef::Log.debug("#{new_resource} raid device doesn't exist (#{new_resource.raid_device}) - not stopping")
         end
       end
 

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

@@ -116,9 +116,9 @@ class Chef
 
         def remount_command
           if !(@new_resource.options.nil? || @new_resource.options.empty?)
-            return "mount -o remount,#{@new_resource.options.join(',')} #{@new_resource.device} #{@new_resource.mount_point}"
+            "mount -o remount,#{@new_resource.options.join(',')} #{@new_resource.device} #{@new_resource.mount_point}"
           else
-            return "mount -o remount #{@new_resource.device} #{@new_resource.mount_point}"
+            "mount -o remount #{@new_resource.device} #{@new_resource.mount_point}"
           end
         end
 

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

@@ -47,7 +47,7 @@ class Chef
           elsif @new_resource.mount_point != "none" && !::File.exists?(@new_resource.mount_point)
             raise Chef::Exceptions::Mount, "Mount point #{@new_resource.mount_point} does not exist"
           end
-          return true
+          true
         end
 
         def enabled?
@@ -129,7 +129,7 @@ class Chef
         end
 
         def remount_command
-          return "mount -o remount,#{@new_resource.options.join(',')} #{@new_resource.mount_point}"
+          "mount -o remount,#{@new_resource.options.join(',')} #{@new_resource.mount_point}"
         end
 
         def remount_fs

data/lib/chef/provider/ohai.rb

@@ -37,7 +37,7 @@ class Chef
         converge_by("re-run ohai and merge results into node attributes") do
           ohai = ::Ohai::System.new
 
-          # If @new_resource.plugin is nil, ohai will reload all the plugins
+          # If new_resource.plugin is nil, ohai will reload all the plugins
           # Otherwise it will only reload the specified plugin
           # Note that any changes to plugins, or new plugins placed on
           # the path are picked up by ohai.

data/lib/chef/provider/osx_profile.rb

@@ -34,16 +34,16 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::OsxProfile.new(@new_resource.name)
-        @current_resource.profile_name(@new_resource.profile_name)
+        @current_resource = Chef::Resource::OsxProfile.new(new_resource.name)
+        current_resource.profile_name(new_resource.profile_name)
 
         all_profiles = get_installed_profiles
-        @new_resource.profile(
-          @new_resource.profile ||
-          @new_resource.profile_name
+        new_resource.profile(
+          new_resource.profile ||
+          new_resource.profile_name
         )
 
-        @new_profile_hash = get_profile_hash(@new_resource.profile)
+        @new_profile_hash = get_profile_hash(new_resource.profile)
         if @new_profile_hash
           @new_profile_hash["PayloadUUID"] =
             config_uuid(@new_profile_hash)
@@ -52,8 +52,8 @@ class Chef
         if @new_profile_hash
           @new_profile_identifier = @new_profile_hash["PayloadIdentifier"]
         else
-          @new_profile_identifier = @new_resource.identifier ||
-            @new_resource.profile_name
+          @new_profile_identifier = new_resource.identifier ||
+            new_resource.profile_name
         end
 
         current_profile = nil
@@ -62,7 +62,7 @@ class Chef
             item["ProfileIdentifier"] == @new_profile_identifier
           end
         end
-        @current_resource.profile(current_profile)
+        current_resource.profile(current_profile)
       end
 
       def define_resource_requirements
@@ -75,7 +75,7 @@ class Chef
             end
             a.failure_message RuntimeError, "when removing using the identifier attribute, it must match the profile identifier"
           else
-            new_profile_name = @new_resource.profile_name
+            new_profile_name = new_resource.profile_name
             a.assertion do
               !new_profile_name.end_with?(".mobileconfig") &&
                 /^\w+(?:(\.| )\w+)+$/.match(new_profile_name)
@@ -128,21 +128,21 @@ class Chef
             raise Chef::Exceptions::FileNotFound, error_string
           end
           cookbook_profile = cache_cookbook_profile(new_profile)
-          return read_plist(cookbook_profile)
+          read_plist(cookbook_profile)
         else
-          return nil
+          nil
         end
       end
 
       def cookbook_file_available?(cookbook_file)
         run_context.has_cookbook_file_in_cookbook?(
-          @new_resource.cookbook_name, cookbook_file
+          new_resource.cookbook_name, cookbook_file
         )
       end
 
       def get_cache_dir
         cache_dir = Chef::FileCache.create_cache_path(
-          "profiles/#{@new_resource.cookbook_name}"
+          "profiles/#{new_resource.cookbook_name}"
         )
       end
 
@@ -150,7 +150,7 @@ class Chef
         Chef::FileCache.create_cache_path(
           ::File.join(
             "profiles",
-            @new_resource.cookbook_name,
+            new_resource.cookbook_name,
             ::File.dirname(cookbook_file)
           )
         )
@@ -161,7 +161,7 @@ class Chef
           ),
           run_context
         )
-        remote_file.cookbook_name = @new_resource.cookbook_name
+        remote_file.cookbook_name = new_resource.cookbook_name
         remote_file.source(cookbook_file)
         remote_file.backup(false)
         remote_file.run_action(:create)
@@ -170,9 +170,9 @@ class Chef
 
       def get_profile_hash(new_profile)
         if new_profile.is_a?(Hash)
-          return new_profile
+          new_profile
         elsif new_profile.is_a?(String)
-          return load_profile_hash(new_profile)
+          load_profile_hash(new_profile)
         end
       end
 
@@ -185,8 +185,8 @@ class Chef
       end
 
       def write_profile_to_disk
-        @new_resource.path(Chef::FileCache.create_cache_path("profiles"))
-        tempfile = Chef::FileContentManagement::Tempfile.new(@new_resource).tempfile
+        new_resource.path(Chef::FileCache.create_cache_path("profiles"))
+        tempfile = Chef::FileContentManagement::Tempfile.new(new_resource).tempfile
         tempfile.write(@new_profile_hash.to_plist)
         tempfile.close
         tempfile.path
@@ -240,13 +240,13 @@ class Chef
 
       def profile_installed?
         # Profile Identifier and UUID must match a currently installed profile
-        if @current_resource.profile.nil? || @current_resource.profile.empty?
+        if current_resource.profile.nil? || current_resource.profile.empty?
           false
         else
-          if @new_resource.action.include?(:remove)
+          if new_resource.action.include?(:remove)
             true
           else
-            @current_resource.profile["ProfileUUID"] ==
+            current_resource.profile["ProfileUUID"] ==
               @new_profile_hash["PayloadUUID"]
           end
         end