chef 13.2.20-universal-mingw32 → 13.3.42-universal-mingw32

data/lib/chef/provider/execute.rb

@@ -27,7 +27,7 @@ class Chef
 
       provides :execute
 
-      def_delegators :new_resource, :command, :returns, :environment, :user, :domain, :password, :group, :cwd, :umask, :creates
+      def_delegators :new_resource, :command, :returns, :environment, :user, :domain, :password, :group, :cwd, :umask, :creates, :elevated
 
       def load_current_resource
         current_resource = Chef::Resource::Execute.new(new_resource.name)
@@ -55,7 +55,7 @@ class Chef
 
         converge_by("execute #{description}") do
           begin
-            shell_out!(command, opts)
+            shell_out_with_systems_locale!(command, opts)
           rescue Mixlib::ShellOut::ShellCommandFailed
             if sensitive?
               raise Mixlib::ShellOut::ShellCommandFailed,
@@ -102,6 +102,7 @@ class Chef
             opts[:live_stream] = STDOUT
           end
         end
+        opts[:elevated] = elevated if elevated
         opts
       end
 

data/lib/chef/provider/http_request.rb

@@ -62,6 +62,20 @@ class Chef
         end
       end
 
+      # Send a PATCH request to new_resource.url, with the message as the payload
+      def action_patch
+        converge_by("#{new_resource} PATCH to #{new_resource.url}") do
+          message = check_message(new_resource.message)
+          body = @http.patch(
+            "#{new_resource.url}",
+            message,
+            new_resource.headers
+          )
+          Chef::Log.info("#{new_resource} PATCH to #{new_resource.url} successful")
+          Chef::Log.debug("#{new_resource} PATCH request response: #{body}")
+        end
+      end
+
       # 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

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

@@ -40,30 +40,60 @@ class Chef
           # Check to see if there is an entry in /etc/filesystems. Last entry for a volume wins. Using command "lsfs" to fetch entries.
           enabled = false
 
+          regex_arr = device_fstab_regex.split(":")
+          if regex_arr.size.eql?(2)
+            nodename = regex_arr[0]
+            devicename   = regex_arr[1]
+          else
+            devicename   = regex_arr[0]
+          end
           # lsfs o/p = #MountPoint:Device:Vfs:Nodename:Type:Size:Options:AutoMount:Acct
           # search only for current mount point
           shell_out("lsfs -c #{@new_resource.mount_point}").stdout.each_line do |line|
             case line
             when /^#\s/
               next
-            when /^#{Regexp.escape(@new_resource.mount_point)}:#{device_fstab_regex}:(\S+):(\[\S+\])?:(\S+)?:(\S+):(\S+):(\S+):(\S+)/
+            when /^#{Regexp.escape(@new_resource.mount_point)}:#{devicename}:(\S+):#{nodename}:(\S+)?:(\S+):(\S+):(\S+):(\S+)/
               # mount point entry with ipv6 address for nodename (ipv6 address use ':')
               enabled = true
               @current_resource.fstype($1)
-              @current_resource.options($5)
-              Chef::Log.debug("Found mount #{device_fstab} to #{@new_resource.mount_point} in /etc/filesystems")
+              @current_resource.options($4)
+              Chef::Log.debug("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
               next
-            when /^#{Regexp.escape(@new_resource.mount_point)}:#{device_fstab_regex}::(\S+):(\S+)?:(\S+)?:(\S+):(\S+):(\S+):(\S+)/
+            when /^#{Regexp.escape(@new_resource.mount_point)}:#{nodename}:(\S+)::(\S+)?:(\S+):(\S+):(\S+):(\S+)/
               # mount point entry with hostname or ipv4 address
               enabled = true
               @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")
+              next
+            when /^#{Regexp.escape(@new_resource.mount_point)}:(\S+)?:(\S+):#{devicename}:(\S+)?:(\S+):(\S+):(\S+):(\S+)/
+              # mount point entry with hostname or ipv4 address
+              enabled = true
+              @current_resource.fstype($2)
               @current_resource.options($5)
-              Chef::Log.debug("Found mount #{device_fstab} to #{@new_resource.mount_point} in /etc/filesystems")
+              @current_resource.device(devicename + "/")
+              Chef::Log.debug("Found mount point #{@new_resource.mount_point} :: device_type #{@current_resource.device_type} in /etc/filesystems")
               next
-            when /^#{Regexp.escape(@new_resource.mount_point)}/
-              enabled = false
-              Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/filesystems")
+            when /^#{Regexp.escape(@new_resource.mount_point)}:(.*?):(.*?):(.*?):(.*?):(.*?):(.*?):(.*?):(.*?)/
+              if $3.split("=")[0].eql?("LABEL") || $1.split("=")[0].eql?("LABEL")
+                @current_resource.device_type("label")
+              elsif $3.split("=")[0].eql?("UUID") || $1.split("=")[0].eql?("UUID")
+                @current_resource.device_type("uuid")
+              else
+                @current_resource.device_type("device")
+              end
+
+              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")
+              else
+                enabled = false
+                Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/filesystems")
+              end
             end
+
           end
           @current_resource.enabled(enabled)
         end
@@ -149,6 +179,17 @@ class Chef
           end
         end
 
+        def mount_options_unchanged?
+          current_resource_options = @current_resource.options.delete_if { |x| x == "rw" }
+
+          @current_resource.device == @new_resource.device &&
+            @current_resource.fsck_device == @new_resource.fsck_device &&
+            @current_resource.fstype == @new_resource.fstype &&
+            current_resource_options == @new_resource.options &&
+            @current_resource.dump == @new_resource.dump &&
+            @current_resource.pass == @new_resource.pass
+        end
+
         def disable_fs
           contents = []
           if @current_resource.enabled

data/lib/chef/provider/package/windows/registry_uninstall_entry.rb

@@ -40,7 +40,7 @@ class Chef
                     begin
                       entry = reg.open(key, desired)
                       display_name = read_registry_property(entry, "DisplayName")
-                      if display_name == package_name
+                      if display_name.to_s.rstrip == package_name
                         quiet_uninstall_string = RegistryUninstallEntry.read_registry_property(entry, "QuietUninstallString")
                         entries.push(quiet_uninstall_string_key?(quiet_uninstall_string, hkey, key, entry))
                       end

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

@@ -103,7 +103,7 @@ class Chef
         end
 
         def install_package(name, version)
-          zypper_package("install", "--auto-agree-with-licenses", name, version)
+          zypper_package("install", *options, "--auto-agree-with-licenses", name, version)
         end
 
         def upgrade_package(name, version)
@@ -112,19 +112,19 @@ class Chef
         end
 
         def remove_package(name, version)
-          zypper_package("remove", name, version)
+          zypper_package("remove", *options, name, version)
         end
 
         def purge_package(name, version)
-          zypper_package("remove", "--clean-deps", name, version)
+          zypper_package("remove", *options, "--clean-deps", name, version)
         end
 
         def lock_package(name, version)
-          zypper_package("addlock", name, version)
+          zypper_package("addlock", *options, name, version)
         end
 
         def unlock_package(name, version)
-          zypper_package("removelock", name, version)
+          zypper_package("removelock", *options, name, version)
         end
 
         private

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

@@ -20,6 +20,7 @@
 require "chef/resource/service"
 require "chef/provider/service/simple"
 require "chef/mixin/which"
+require "shellwords"
 
 class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
 
@@ -100,7 +101,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
         super
       else
         options, args = get_systemctl_options_args
-        shell_out_with_systems_locale!("#{systemctl_path} #{args} start #{new_resource.service_name}", options)
+        shell_out_with_systems_locale!("#{systemctl_path} #{args} start #{Shellwords.escape(new_resource.service_name)}", options)
       end
     end
   end
@@ -113,7 +114,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
         super
       else
         options, args = get_systemctl_options_args
-        shell_out_with_systems_locale!("#{systemctl_path} #{args} stop #{new_resource.service_name}", options)
+        shell_out_with_systems_locale!("#{systemctl_path} #{args} stop #{Shellwords.escape(new_resource.service_name)}", options)
       end
     end
   end
@@ -123,7 +124,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
       super
     else
       options, args = get_systemctl_options_args
-      shell_out_with_systems_locale!("#{systemctl_path} #{args} restart #{new_resource.service_name}", options)
+      shell_out_with_systems_locale!("#{systemctl_path} #{args} restart #{Shellwords.escape(new_resource.service_name)}", options)
     end
   end
 
@@ -133,7 +134,7 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
     else
       if current_resource.running
         options, args = get_systemctl_options_args
-        shell_out_with_systems_locale!("#{systemctl_path} #{args} reload #{new_resource.service_name}", options)
+        shell_out_with_systems_locale!("#{systemctl_path} #{args} reload #{Shellwords.escape(new_resource.service_name)}", options)
       else
         start_service
       end
@@ -142,37 +143,37 @@ class Chef::Provider::Service::Systemd < Chef::Provider::Service::Simple
 
   def enable_service
     options, args = get_systemctl_options_args
-    shell_out!("#{systemctl_path} #{args} enable #{new_resource.service_name}", options)
+    shell_out!("#{systemctl_path} #{args} enable #{Shellwords.escape(new_resource.service_name)}", options)
   end
 
   def disable_service
     options, args = get_systemctl_options_args
-    shell_out!("#{systemctl_path} #{args} disable #{new_resource.service_name}", options)
+    shell_out!("#{systemctl_path} #{args} disable #{Shellwords.escape(new_resource.service_name)}", options)
   end
 
   def mask_service
     options, args = get_systemctl_options_args
-    shell_out!("#{systemctl_path} #{args} mask #{new_resource.service_name}", options)
+    shell_out!("#{systemctl_path} #{args} mask #{Shellwords.escape(new_resource.service_name)}", options)
   end
 
   def unmask_service
     options, args = get_systemctl_options_args
-    shell_out!("#{systemctl_path} #{args} unmask #{new_resource.service_name}", options)
+    shell_out!("#{systemctl_path} #{args} unmask #{Shellwords.escape(new_resource.service_name)}", options)
   end
 
   def is_active?
     options, args = get_systemctl_options_args
-    shell_out("#{systemctl_path} #{args} is-active #{new_resource.service_name} --quiet", options).exitstatus == 0
+    shell_out("#{systemctl_path} #{args} is-active #{Shellwords.escape(new_resource.service_name)} --quiet", options).exitstatus == 0
   end
 
   def is_enabled?
     options, args = get_systemctl_options_args
-    shell_out("#{systemctl_path} #{args} is-enabled #{new_resource.service_name} --quiet", options).exitstatus == 0
+    shell_out("#{systemctl_path} #{args} is-enabled #{Shellwords.escape(new_resource.service_name)} --quiet", options).exitstatus == 0
   end
 
   def is_masked?
     options, args = get_systemctl_options_args
-    s = shell_out("#{systemctl_path} #{args} is-enabled #{new_resource.service_name}", options)
+    s = shell_out("#{systemctl_path} #{args} is-enabled #{Shellwords.escape(new_resource.service_name)}", options)
     s.exitstatus != 0 && s.stdout.include?("masked")
   end
 

data/lib/chef/provider/support/zypper_repo.erb

@@ -0,0 +1,17 @@
+# This file was generated by Chef
+# Do NOT modify this file by hand.
+
+[<%= @config.repo_name %>]
+<% %w{ type enabled autorefresh gpgcheck gpgkey baseurl mirrorlist path priority keeppackages mode refresh_cache }.each do |prop| -%>
+<%  next if @config.send(prop.to_sym).nil? -%>
+<%= prop %>=<%=
+       case @config.send(prop.to_sym)
+       when TrueClass
+         '1'
+       when FalseClass
+         '0'
+       else
+         @config.send(prop.to_sym)
+       end %>
+<% end -%>
+name=<%= @config.description || @config.repo_name %>

data/lib/chef/provider/systemd_unit.rb

@@ -22,6 +22,7 @@ require "chef/mixin/shell_out"
 require "chef/resource/file"
 require "chef/resource/file/verification/systemd_unit"
 require "iniparse"
+require "shellwords"
 
 class Chef
   class Provider
@@ -203,11 +204,11 @@ class Chef
       end
 
       def systemctl_execute!(action, unit)
-        shell_out_with_systems_locale!("#{systemctl_cmd} #{action} #{unit}", systemctl_opts)
+        shell_out_with_systems_locale!("#{systemctl_cmd} #{action} #{Shellwords.escape(unit)}", systemctl_opts)
       end
 
       def systemctl_execute(action, unit)
-        shell_out("#{systemctl_cmd} #{action} #{unit}", systemctl_opts)
+        shell_out("#{systemctl_cmd} #{action} #{Shellwords.escape(unit)}", systemctl_opts)
       end
 
       def systemctl_cmd

data/lib/chef/provider/windows_task.rb

@@ -52,53 +52,74 @@ class Chef
         set_current_idle_time(task_hash[:idle_time]) if task_hash[:idle_time]
         @current_resource.random_delay(task_hash[:random_delay]) if task_hash[:random_delay]
         @current_resource.execution_time_limit(task_hash[:execution_time_limit]) if task_hash[:execution_time_limit]
-
         @current_resource.status = :running if task_hash[:Status] == "Running"
         @current_resource.enabled = true if task_hash[:ScheduledTaskState] == "Enabled"
       end
 
-      def action_create
-        if @current_resource.exists && !(task_need_update? || @new_resource.force)
-          Chef::Log.info "#{@new_resource} task already exists - nothing to do"
-        else
-          options = {}
-          options["F"] = "" if @new_resource.force || task_need_update?
-          options["SC"] = schedule
-          options["MO"] = @new_resource.frequency_modifier if frequency_modifier_allowed
-          options["I"]  = @new_resource.idle_time unless @new_resource.idle_time.nil?
-          options["SD"] = @new_resource.start_day unless @new_resource.start_day.nil?
-          options["ST"] = @new_resource.start_time unless @new_resource.start_time.nil?
-          options["TR"] = @new_resource.command
-          options["RU"] = @new_resource.user
-          options["RP"] = @new_resource.password if use_password?
-          options["RL"] = "HIGHEST" if @new_resource.run_level == :highest
-          options["IT"] = "" if @new_resource.interactive_enabled
-          options["D"] = @new_resource.day if @new_resource.day
-          options["M"] = @new_resource.months unless @new_resource.months.nil?
-
-          run_schtasks "CREATE", options
-          xml_options = []
-          xml_options << "cwd" if new_resource.cwd
-          xml_options << "random_delay" if new_resource.random_delay
-          xml_options << "execution_time_limit" if new_resource.execution_time_limit
-          update_task_xml(xml_options) unless xml_options.empty?
+      # This method checks if task and command attributes exist since those two are mandatory attributes to create a schedules task.
+      def basic_validation
+        validate = []
+        validate << "Command" if new_resource.command.nil? || new_resource.command.empty?
+        validate << "Task Name" if new_resource.task_name.nil? || new_resource.task_name.empty?
+        return true if validate.empty?
+        raise Chef::Exceptions::ValidationFailed.new "Value for '#{validate.join(', ')}' option cannot be empty"
+      end
 
-          new_resource.updated_by_last_action true
-          Chef::Log.info "#{@new_resource} task created"
+      # get array of windows task resource attributes
+      def resource_attributes
+        %w{ command user run_level cwd frequency_modifier frequency idle_time random_delay execution_time_limit start_day start_time }
+      end
+
+      def action_create
+        if @current_resource.exists
+          if !(task_need_update? || new_resource.force)
+            Chef::Log.info "#{new_resource} task already exists - nothing to do"
+            return
+          end
+          # To merge current resource and new resource attributes
+          resource_attributes.each do |attribute|
+            new_resource_attribute = new_resource.send(attribute)
+            current_resource_attribute = @current_resource.send(attribute)
+            new_resource.send("#{attribute}=", current_resource_attribute ) if current_resource_attribute && new_resource_attribute.nil?
+          end
         end
+        basic_validation
+        options = {}
+        options["F"] = "" if new_resource.force || task_need_update?
+        options["SC"] = schedule
+        options["MO"] = new_resource.frequency_modifier if frequency_modifier_allowed
+        options["I"]  = new_resource.idle_time unless new_resource.idle_time.nil?
+        options["SD"] = new_resource.start_day unless new_resource.start_day.nil?
+        options["ST"] = new_resource.start_time unless new_resource.start_time.nil?
+        options["TR"] = new_resource.command
+        options["RU"] = new_resource.user
+        options["RP"] = new_resource.password if use_password?
+        options["RL"] = "HIGHEST" if new_resource.run_level == :highest
+        options["IT"] = "" if new_resource.interactive_enabled
+        options["D"] = new_resource.day if new_resource.day
+        options["M"] = new_resource.months unless new_resource.months.nil?
+        run_schtasks "CREATE", options
+        xml_options = []
+        xml_options << "cwd" if new_resource.cwd
+        xml_options << "random_delay" if new_resource.random_delay
+        xml_options << "execution_time_limit" if new_resource.execution_time_limit
+        update_task_xml(xml_options) unless xml_options.empty?
+
+        new_resource.updated_by_last_action true
+        Chef::Log.info "#{new_resource} task created"
       end
 
       def action_run
         if @current_resource.exists
           if @current_resource.status == :running
-            Chef::Log.info "#{@new_resource} task is currently running, skipping run"
+            Chef::Log.info "#{new_resource} task is currently running, skipping run"
           else
             run_schtasks "RUN"
             new_resource.updated_by_last_action true
-            Chef::Log.info "#{@new_resource} task ran"
+            Chef::Log.info "#{new_resource} task ran"
           end
         else
-          Chef::Log.warn "#{@new_resource} task doesn't exists - nothing to do"
+          Chef::Log.warn "#{new_resource} task doesn't exists - nothing to do"
         end
       end
 
@@ -107,38 +128,38 @@ class Chef
           # always need to force deletion
           run_schtasks "DELETE", "F" => ""
           new_resource.updated_by_last_action true
-          Chef::Log.info "#{@new_resource} task deleted"
+          Chef::Log.info "#{new_resource} task deleted"
         else
-          Chef::Log.warn "#{@new_resource} task doesn't exists - nothing to do"
+          Chef::Log.warn "#{new_resource} task doesn't exists - nothing to do"
         end
       end
 
       def action_end
         if @current_resource.exists
           if @current_resource.status != :running
-            Chef::Log.debug "#{@new_resource} is not running - nothing to do"
+            Chef::Log.debug "#{new_resource} is not running - nothing to do"
           else
             run_schtasks "END"
-            @new_resource.updated_by_last_action true
-            Chef::Log.info "#{@new_resource} task ended"
+            new_resource.updated_by_last_action true
+            Chef::Log.info "#{new_resource} task ended"
           end
         else
-          Chef::Log.warn "#{@new_resource} task doesn't exist - nothing to do"
+          Chef::Log.warn "#{new_resource} task doesn't exist - nothing to do"
         end
       end
 
       def action_enable
         if @current_resource.exists
           if @current_resource.enabled
-            Chef::Log.debug "#{@new_resource} already enabled - nothing to do"
+            Chef::Log.debug "#{new_resource} already enabled - nothing to do"
           else
             run_schtasks "CHANGE", "ENABLE" => ""
-            @new_resource.updated_by_last_action true
-            Chef::Log.info "#{@new_resource} task enabled"
+            new_resource.updated_by_last_action true
+            Chef::Log.info "#{new_resource} task enabled"
           end
         else
-          Chef::Log.fatal "#{@new_resource} task doesn't exist - nothing to do"
-          raise Errno::ENOENT, "#{@new_resource}: task does not exist, cannot enable"
+          Chef::Log.fatal "#{new_resource} task doesn't exist - nothing to do"
+          raise Errno::ENOENT, "#{new_resource}: task does not exist, cannot enable"
         end
       end
 
@@ -146,13 +167,13 @@ class Chef
         if @current_resource.exists
           if @current_resource.enabled
             run_schtasks "CHANGE", "DISABLE" => ""
-            @new_resource.updated_by_last_action true
-            Chef::Log.info "#{@new_resource} task disabled"
+            new_resource.updated_by_last_action true
+            Chef::Log.info "#{new_resource} task disabled"
           else
-            Chef::Log.warn "#{@new_resource} already disabled - nothing to do"
+            Chef::Log.warn "#{new_resource} already disabled - nothing to do"
           end
         else
-          Chef::Log.warn "#{@new_resource} task doesn't exist - nothing to do"
+          Chef::Log.warn "#{new_resource} task doesn't exist - nothing to do"
         end
       end
 
@@ -160,7 +181,7 @@ class Chef
 
       # rubocop:disable Style/StringLiteralsInInterpolation
       def run_schtasks(task_action, options = {})
-        cmd = "schtasks /#{task_action} /TN \"#{@new_resource.task_name}\" "
+        cmd = "schtasks /#{task_action} /TN \"#{new_resource.task_name}\" "
         options.keys.each do |option|
           cmd += "/#{option} "
           cmd += "\"#{options[option].to_s.gsub('"', "\\\"")}\" " unless options[option] == ""
@@ -172,20 +193,20 @@ class Chef
       # rubocop:enable Style/StringLiteralsInInterpolation
 
       def task_need_update?
-        return true if @current_resource.command != @new_resource.command.tr("'", '"') ||
-            @current_resource.user != @new_resource.user ||
-            @current_resource.run_level != @new_resource.run_level ||
-            @current_resource.cwd != @new_resource.cwd ||
-            @current_resource.frequency_modifier != @new_resource.frequency_modifier ||
-            @current_resource.frequency != @new_resource.frequency ||
-            @current_resource.idle_time != @new_resource.idle_time ||
-            @current_resource.random_delay != @new_resource.random_delay ||
-            @current_resource.execution_time_limit != @new_resource.execution_time_limit ||
-            !@new_resource.start_day.nil? || !@new_resource.start_time.nil?
-
+        return true if (new_resource.command &&
+            @current_resource.command != new_resource.command.tr("'", '"')) ||
+            @current_resource.user != new_resource.user ||
+            @current_resource.run_level != new_resource.run_level ||
+            @current_resource.cwd != new_resource.cwd ||
+            @current_resource.frequency_modifier != new_resource.frequency_modifier ||
+            @current_resource.frequency != new_resource.frequency ||
+            @current_resource.idle_time != new_resource.idle_time ||
+            @current_resource.random_delay != new_resource.random_delay ||
+            @current_resource.execution_time_limit != new_resource.execution_time_limit ||
+            !new_resource.start_day.nil? || !new_resource.start_time.nil?
         begin
-          return true if @new_resource.day.to_s.casecmp(@current_resource.day.to_s) != 0 ||
-              @new_resource.months.to_s.casecmp(@current_resource.months.to_s) != 0
+          return true if new_resource.day.to_s.casecmp(@current_resource.day.to_s) != 0 ||
+              new_resource.months.to_s.casecmp(@current_resource.months.to_s) != 0
         rescue
           Chef::Log.debug "caught a raise in task_needs_update?"
         end
@@ -206,7 +227,7 @@ class Chef
 
         xml_element_mapping = {
           "cwd" => "Actions/Exec/WorkingDirectory",
-          "random_delay" => random_delay_xml_element[@new_resource.frequency],
+          "random_delay" => random_delay_xml_element[new_resource.frequency],
           "execution_time_limit" => "Settings/ExecutionTimeLimit",
         }
 
@@ -214,7 +235,7 @@ class Chef
 
         task_script = <<-EOH
             [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
-            schtasks /Query /TN \"#{@new_resource.task_name}\" /XML
+            schtasks /Query /TN \"#{new_resource.task_name}\" /XML
         EOH
         xml_cmd = powershell_out(task_script)
 
@@ -225,7 +246,7 @@ class Chef
         options.each do |option|
           Chef::Log.debug 'Removing former #{option} if any'
           doc.root.elements.delete(xml_element_mapping[option])
-          option_value = @new_resource.send("#{option}")
+          option_value = new_resource.send("#{option}")
 
           if option_value
             Chef::Log.debug "Setting #option as #option_value"
@@ -246,9 +267,9 @@ class Chef
           end
 
           options = {}
-          options["RU"] = @new_resource.user if @new_resource.user
-          options["RP"] = @new_resource.password if @new_resource.password
-          options["IT"] = "" if @new_resource.interactive_enabled
+          options["RU"] = new_resource.user if new_resource.user
+          options["RP"] = new_resource.password if new_resource.password
+          options["IT"] = "" if new_resource.interactive_enabled
           options["XML"] = temp_task_file
 
           run_schtasks("DELETE", "F" => "")
@@ -345,26 +366,26 @@ class Chef
       SYSTEM_USERS = ['NT AUTHORITY\SYSTEM', "SYSTEM", 'NT AUTHORITY\LOCALSERVICE', 'NT AUTHORITY\NETWORKSERVICE', 'BUILTIN\USERS', "USERS"].freeze
 
       def use_password?
-        @use_password ||= !SYSTEM_USERS.include?(@new_resource.user.upcase)
+        @use_password ||= !SYSTEM_USERS.include?(new_resource.user.upcase)
       end
 
       def schedule
-        case @new_resource.frequency
+        case new_resource.frequency
         when :on_logon
           "ONLOGON"
         when :on_idle
           "ONIDLE"
         else
-          @new_resource.frequency
+          new_resource.frequency
         end
       end
 
       def frequency_modifier_allowed
-        case @new_resource.frequency
+        case new_resource.frequency
         when :minute, :hourly, :daily, :weekly
           true
         when :monthly
-          @new_resource.months.nil? || %w{ FIRST SECOND THIRD FOURTH LAST LASTDAY }.include?(@new_resource.frequency_modifier)
+          new_resource.months.nil? || %w{ FIRST SECOND THIRD FOURTH LAST LASTDAY }.include?(new_resource.frequency_modifier)
         else
           false
         end