chef 13.6.4-universal-mingw32 → 13.7.16-universal-mingw32

data/lib/chef/provider/systemd_unit.rb

@@ -35,6 +35,7 @@ class Chef
       def load_current_resource
         @current_resource = Chef::Resource::SystemdUnit.new(new_resource.name)
 
+        current_resource.unit_name(new_resource.unit_name)
         current_resource.content(::File.read(unit_path)) if ::File.exist?(unit_path)
         current_resource.user(new_resource.user)
         current_resource.enabled(enabled?)
@@ -57,7 +58,7 @@ class Chef
 
       def action_create
         if current_resource.content != new_resource.to_ini
-          converge_by("creating unit: #{new_resource.name}") do
+          converge_by("creating unit: #{new_resource.unit_name}") do
             manage_unit_file(:create)
             daemon_reload if new_resource.triggers_reload
           end
@@ -66,7 +67,7 @@ class Chef
 
       def action_delete
         if ::File.exist?(unit_path)
-          converge_by("deleting unit: #{new_resource.name}") do
+          converge_by("deleting unit: #{new_resource.unit_name}") do
             manage_unit_file(:delete)
             daemon_reload if new_resource.triggers_reload
           end
@@ -75,117 +76,117 @@ class Chef
 
       def action_enable
         if current_resource.static
-          Chef::Log.debug("#{new_resource.name} is a static unit, enabling is a NOP.")
+          Chef::Log.debug("#{new_resource.unit_name} is a static unit, enabling is a NOP.")
         end
 
         unless current_resource.enabled || current_resource.static
-          converge_by("enabling unit: #{new_resource.name}") do
-            systemctl_execute!(:enable, new_resource.name)
+          converge_by("enabling unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:enable, new_resource.unit_name)
           end
         end
       end
 
       def action_disable
         if current_resource.static
-          Chef::Log.debug("#{new_resource.name} is a static unit, disabling is a NOP.")
+          Chef::Log.debug("#{new_resource.unit_name} is a static unit, disabling is a NOP.")
         end
 
         if current_resource.enabled && !current_resource.static
-          converge_by("disabling unit: #{new_resource.name}") do
-            systemctl_execute!(:disable, new_resource.name)
+          converge_by("disabling unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:disable, new_resource.unit_name)
           end
         end
       end
 
       def action_mask
         unless current_resource.masked
-          converge_by("masking unit: #{new_resource.name}") do
-            systemctl_execute!(:mask, new_resource.name)
+          converge_by("masking unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:mask, new_resource.unit_name)
           end
         end
       end
 
       def action_unmask
         if current_resource.masked
-          converge_by("unmasking unit: #{new_resource.name}") do
-            systemctl_execute!(:unmask, new_resource.name)
+          converge_by("unmasking unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:unmask, new_resource.unit_name)
           end
         end
       end
 
       def action_start
         unless current_resource.active
-          converge_by("starting unit: #{new_resource.name}") do
-            systemctl_execute!(:start, new_resource.name)
+          converge_by("starting unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:start, new_resource.unit_name)
           end
         end
       end
 
       def action_stop
         if current_resource.active
-          converge_by("stopping unit: #{new_resource.name}") do
-            systemctl_execute!(:stop, new_resource.name)
+          converge_by("stopping unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:stop, new_resource.unit_name)
           end
         end
       end
 
       def action_restart
-        converge_by("restarting unit: #{new_resource.name}") do
-          systemctl_execute!(:restart, new_resource.name)
+        converge_by("restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!(:restart, new_resource.unit_name)
         end
       end
 
       def action_reload
         if current_resource.active
-          converge_by("reloading unit: #{new_resource.name}") do
-            systemctl_execute!(:reload, new_resource.name)
+          converge_by("reloading unit: #{new_resource.unit_name}") do
+            systemctl_execute!(:reload, new_resource.unit_name)
           end
         else
-          Chef::Log.debug("#{new_resource.name} is not active, skipping reload.")
+          Chef::Log.debug("#{new_resource.unit_name} is not active, skipping reload.")
         end
       end
 
       def action_try_restart
-        converge_by("try-restarting unit: #{new_resource.name}") do
-          systemctl_execute!("try-restart", new_resource.name)
+        converge_by("try-restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!("try-restart", new_resource.unit_name)
         end
       end
 
       def action_reload_or_restart
-        converge_by("reload-or-restarting unit: #{new_resource.name}") do
-          systemctl_execute!("reload-or-restart", new_resource.name)
+        converge_by("reload-or-restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!("reload-or-restart", new_resource.unit_name)
         end
       end
 
       def action_reload_or_try_restart
-        converge_by("reload-or-try-restarting unit: #{new_resource.name}") do
-          systemctl_execute!("reload-or-try-restart", new_resource.name)
+        converge_by("reload-or-try-restarting unit: #{new_resource.unit_name}") do
+          systemctl_execute!("reload-or-try-restart", new_resource.unit_name)
         end
       end
 
       def active?
-        systemctl_execute("is-active", new_resource.name).exitstatus == 0
+        systemctl_execute("is-active", new_resource.unit_name).exitstatus == 0
       end
 
       def enabled?
-        systemctl_execute("is-enabled", new_resource.name).exitstatus == 0
+        systemctl_execute("is-enabled", new_resource.unit_name).exitstatus == 0
       end
 
       def masked?
-        systemctl_execute(:status, new_resource.name).stdout.include?("masked")
+        systemctl_execute(:status, new_resource.unit_name).stdout.include?("masked")
       end
 
       def static?
-        systemctl_execute("is-enabled", new_resource.name).stdout.include?("static")
+        systemctl_execute("is-enabled", new_resource.unit_name).stdout.include?("static")
       end
 
       private
 
       def unit_path
         if new_resource.user
-          "/etc/systemd/user/#{new_resource.name}"
+          "/etc/systemd/user/#{new_resource.unit_name}"
         else
-          "/etc/systemd/system/#{new_resource.name}"
+          "/etc/systemd/system/#{new_resource.unit_name}"
         end
       end
 

data/lib/chef/provider/user/dscl.rb

@@ -318,7 +318,7 @@ user password using shadow hash.")
         end
 
         def current_home_exists?
-          ::File.exist?(current_resource.home)
+          !!current_resource.home && ::File.exist?(current_resource.home)
         end
 
         def new_home_exists?

data/lib/chef/provider/windows_path.rb

@@ -23,9 +23,10 @@ require "chef/exceptions"
 class Chef
   class Provider
     class WindowsPath < Chef::Provider
-
       include Chef::Mixin::WindowsEnvHelper if Chef::Platform.windows?
 
+      provides :windows_path
+
       def load_current_resource
         @current_resource = Chef::Resource::WindowsPath.new(new_resource.name)
         @current_resource.path(new_resource.path)
@@ -37,12 +38,10 @@ class Chef
         # the PATH environment variable. Ruby expects these to be expanded.
         #
         path = expand_path(new_resource.path)
-        converge_by "Adding #{new_resource.path} to path environment variable" do
-          declare_resource(:env, "path") do
-            action :modify
-            delim ::File::PATH_SEPARATOR
-            value path.tr("/", '\\')
-          end
+        declare_resource(:env, "path") do
+          action :modify
+          delim ::File::PATH_SEPARATOR
+          value path.tr("/", '\\')
         end
       end
 

data/lib/chef/provider/windows_task.rb

@@ -75,14 +75,22 @@ class Chef
 
       def action_create
         if current_resource.exists
+          Chef::Log.debug "#{new_resource} task exists."
           if !(task_need_update? || new_resource.force)
-            Chef::Log.info "#{new_resource} task already exists - nothing to do"
+            Chef::Log.info "#{new_resource} task doesn't need updating and force not specified - nothing to do"
             return
           end
-          # To merge current resource and new resource attributes
+          # Setting the attributes of new_resource as current_resource.
+          # This is required to handle update scenarios when the user specifies
+          # only those attributes in the recipe which require update
           resource_attributes.each do |attribute|
             new_resource_attribute = new_resource.send(attribute)
             current_resource_attribute = current_resource.send(attribute)
+            # We accept start_day in mm/dd/yyyy format only. Hence while copying the start_day from system to new_resource.start_day,
+            # we are converting from system date format to mm/dd/yyyy
+            current_resource_attribute = convert_system_date_to_mm_dd_yyyy(current_resource_attribute) if attribute == "start_day" && current_resource_attribute != "N/A"
+            # Convert start_time into 24hr time format
+            current_resource_attribute = DateTime.parse(current_resource_attribute).strftime("%H:%M") if attribute == "start_time" && current_resource_attribute != "N/A"
             new_resource.send("#{attribute}=", current_resource_attribute ) if current_resource_attribute && new_resource_attribute.nil?
           end
         end
@@ -95,8 +103,8 @@ class Chef
           options["SD"] = convert_user_date_to_system_date "12/12/2012"
         else
           options["SC"] = schedule
-          options["ST"] = new_resource.start_time unless new_resource.start_time.nil?
-          options["SD"] = convert_user_date_to_system_date new_resource.start_day unless new_resource.start_day.nil?
+          options["ST"] = new_resource.start_time unless new_resource.start_time.nil? || new_resource.start_time == "N/A"
+          options["SD"] = convert_user_date_to_system_date new_resource.start_day unless new_resource.start_day.nil? || new_resource.start_day == "N/A"
         end
         options["MO"] = new_resource.frequency_modifier if frequency_modifier_allowed
         options["I"]  = new_resource.idle_time unless new_resource.idle_time.nil?
@@ -112,20 +120,21 @@ class Chef
         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"
+        converge_by("#{new_resource} task created") do
+          update_task_xml(xml_options) unless xml_options.empty?
+        end
       end
 
       def action_run
         if current_resource.exists
+          Chef::Log.debug "#{new_resource} task 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"
+            converge_by("run scheduled task #{new_resource}") do
+              run_schtasks "RUN"
+            end
           end
         else
           Chef::Log.warn "#{new_resource} task doesn't exists - nothing to do"
@@ -134,10 +143,11 @@ class Chef
 
       def action_delete
         if current_resource.exists
-          # 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.debug "#{new_resource} task exists."
+          converge_by("delete scheduled task #{new_resource}") do
+            # always need to force deletion
+            run_schtasks "DELETE", "F" => ""
+          end
         else
           Chef::Log.warn "#{new_resource} task doesn't exists - nothing to do"
         end
@@ -145,12 +155,13 @@ class Chef
 
       def action_end
         if current_resource.exists
+          Chef::Log.debug "#{new_resource} task exists."
           if current_resource.status != :running
             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"
+            converge_by("#{new_resource} task ended") do
+              run_schtasks "END"
+            end
           end
         else
           Chef::Log.warn "#{new_resource} task doesn't exist - nothing to do"
@@ -159,12 +170,13 @@ class Chef
 
       def action_enable
         if current_resource.exists
+          Chef::Log.debug "#{new_resource} task exists."
           if current_resource.enabled
             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"
+            converge_by("#{new_resource} task enabled") do
+              run_schtasks "CHANGE", "ENABLE" => ""
+            end
           end
         else
           Chef::Log.fatal "#{new_resource} task doesn't exist - nothing to do"
@@ -174,10 +186,11 @@ class Chef
 
       def action_disable
         if current_resource.exists
+          Chef::Log.info "#{new_resource} task exists."
           if current_resource.enabled
-            run_schtasks "CHANGE", "DISABLE" => ""
-            new_resource.updated_by_last_action true
-            Chef::Log.info "#{new_resource} task disabled"
+            converge_by("#{new_resource} task disabled") do
+              run_schtasks "CHANGE", "DISABLE" => ""
+            end
           else
             Chef::Log.warn "#{new_resource} already disabled - nothing to do"
           end
@@ -192,8 +205,14 @@ class Chef
       def run_schtasks(task_action, options = {})
         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] == ""
+          unless option == "TR"
+            cmd += "/#{option} "
+            cmd += "\"#{options[option].to_s.gsub('"', "\\\"")}\" " unless options[option] == ""
+          end
+        end
+        # Appending Task Run [TR] option at the end since appending causing sometimes to append other options in option["TR"] value
+        if options["TR"]
+          cmd += "/TR \"#{options["TR"]} \" " unless task_action == "DELETE"
         end
         Chef::Log.debug("running: ")
         Chef::Log.debug("    #{cmd}")
@@ -210,10 +229,9 @@ class Chef
             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 ||
-            !new_resource.execution_time_limit.include?(current_resource.execution_time_limit) ||
-            (new_resource.start_day && start_day_updated?) ||
-            (new_resource.start_time && start_time_updated?)
+            random_delay_updated? || execution_time_limit_updated? ||
+            (new_resource.start_day && new_resource.start_day != "N/A" && start_day_updated?) ||
+            (new_resource.start_time && new_resource.start_time != "N/A" && start_time_updated?)
         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
@@ -224,6 +242,37 @@ class Chef
         false
       end
 
+      # Comparing random_delay values using ISO8601::Duration object Ref: https://github.com/arnau/ISO8601/blob/master/lib/iso8601/duration.rb#L18-L23
+      # di = ISO8601::Duration.new(65707200)
+      # ds = ISO8601::Duration.new('P65707200S')
+      # dp = ISO8601::Duration.new('P2Y1MT2H')
+      # di == dp # => true
+      # di == ds # => true
+      def random_delay_updated?
+        if new_resource.random_delay.nil?
+          false
+        elsif current_resource.random_delay.nil? && new_resource.random_delay == "PT0S" # when user sets random_dealy to 0 sec
+          false
+        elsif current_resource.random_delay.nil?
+          true
+        else
+          ISO8601::Duration.new(current_resource.random_delay) != ISO8601::Duration.new(new_resource.random_delay)
+        end
+      end
+
+      # Comparing execution_time_limit values using Ref: https://github.com/arnau/ISO8601/blob/master/lib/iso8601/duration.rb#L18-L23
+      def execution_time_limit_updated?
+        if new_resource.execution_time_limit.nil?
+          false
+        elsif current_resource.execution_time_limit.nil? && new_resource.execution_time_limit == "PT0S" # when user sets random_dealy to 0 sec
+          false
+        elsif current_resource.execution_time_limit.nil?
+          true
+        else
+          ISO8601::Duration.new(current_resource.execution_time_limit) != ISO8601::Duration.new(new_resource.execution_time_limit)
+        end
+      end
+
       def start_day_updated?
         current_day = DateTime.strptime(current_resource.start_day, convert_system_date_format_to_ruby_date_format)
         new_day = parse_day(new_resource.start_day)
@@ -274,6 +323,14 @@ class Chef
         @system_short_date_format
       end
 
+      def convert_system_date_to_mm_dd_yyyy(system_date)
+        system_date_format = convert_system_date_format_to_ruby_date_format
+        unless system_date_format == "%m/%d/%Y"
+          system_date = Date.strptime(system_date, system_date_format).strftime("%m/%d/%Y")
+        end
+        system_date
+      end
+
       def update_task_xml(options = [])
         # random_delay xml element is different for different frequencies
         random_delay_xml_element = {
@@ -311,12 +368,12 @@ class Chef
         end
 
         options.each do |option|
-          Chef::Log.debug 'Removing former #{option} if any'
+          Chef::Log.debug "Removing former #{option} if any"
           doc.root.elements.delete(xml_element_mapping[option])
           option_value = new_resource.send("#{option}")
 
           if option_value
-            Chef::Log.debug "Setting #option as #option_value"
+            Chef::Log.debug "Setting #{option} as #{option_value}"
             split_xml_path = xml_element_mapping[option].split("/") # eg. if xml_element_mapping[option] = "Actions/Exec/WorkingDirectory"
             element_name = split_xml_path.last # element_name = "WorkingDirectory"
             cwd_element = REXML::Element.new(element_name)
@@ -338,7 +395,6 @@ class Chef
           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" => "")
           run_schtasks("CREATE", options)
         ensure

data/lib/chef/provider/yum_repository.rb

@@ -47,7 +47,7 @@ class Chef
           if new_resource.make_cache
             notifies :run, "execute[yum clean metadata #{new_resource.repositoryid}]", :immediately if new_resource.clean_metadata || new_resource.clean_headers
             notifies :run, "execute[yum-makecache-#{new_resource.repositoryid}]", :immediately
-            notifies :create, "ruby_block[yum-cache-reload-#{new_resource.repositoryid}]", :immediately
+            notifies :create, "ruby_block[package-cache-reload-#{new_resource.repositoryid}]", :immediately
           end
         end
 
@@ -63,9 +63,14 @@ class Chef
           only_if { new_resource.enabled }
         end
 
-        # reload internal Chef yum cache
-        declare_resource(:ruby_block, "yum-cache-reload-#{new_resource.repositoryid}") do
-          block { Chef::Provider::Package::Yum::YumCache.instance.reload }
+        # reload internal Chef yum/dnf cache
+        declare_resource(:ruby_block, "package-cache-reload-#{new_resource.repositoryid}") do
+          if ( platform?("fedora") && node["platform_version"].to_i >= 22 ) ||
+              ( platform_family?("rhel") && node["platform_version"].to_i >= 8 )
+            block { Chef::Provider::Package::Dnf::PythonHelper.instance.restart }
+          else
+            block { Chef::Provider::Package::Yum::YumCache.instance.reload }
+          end
           action :nothing
         end
       end
@@ -79,11 +84,16 @@ class Chef
 
         declare_resource(:file, "/etc/yum.repos.d/#{new_resource.repositoryid}.repo") do
           action :delete
-          notifies :create, "ruby_block[yum-cache-reload-#{new_resource.repositoryid}]", :immediately
+          notifies :create, "ruby_block[package-cache-reload-#{new_resource.repositoryid}]", :immediately
         end
 
-        declare_resource(:ruby_block, "yum-cache-reload-#{new_resource.repositoryid}") do
-          block { Chef::Provider::Package::Yum::YumCache.instance.reload }
+        declare_resource(:ruby_block, "package-cache-reload-#{new_resource.repositoryid}") do
+          if ( platform?("fedora") && node["platform_version"].to_i >= 22 ) ||
+              ( platform_family?("rhel") && node["platform_version"].to_i >= 8 )
+            block { Chef::Provider::Package::Dnf::PythonHelper.instance.restart }
+          else
+            block { Chef::Provider::Package::Yum::YumCache.instance.reload }
+          end
           action :nothing
         end
       end
@@ -95,8 +105,13 @@ class Chef
           only_if { new_resource.enabled }
         end
 
-        declare_resource(:ruby_block, "yum-cache-reload-#{new_resource.repositoryid}") do
-          block { Chef::Provider::Package::Yum::YumCache.instance.reload }
+        declare_resource(:ruby_block, "package-cache-reload-#{new_resource.repositoryid}") do
+          if ( platform?("fedora") && node["platform_version"].to_i >= 22 ) ||
+              ( platform_family?("rhel") && node["platform_version"].to_i >= 8 )
+            block { Chef::Provider::Package::Dnf::PythonHelper.instance.restart }
+          else
+            block { Chef::Provider::Package::Yum::YumCache.instance.reload }
+          end
           action :run
         end
       end