chef 14.0.202 → 14.1.1

data/lib/chef/provider/route.rb

@@ -174,7 +174,7 @@ class Chef
             conf[dev] = "" if conf[dev].nil?
             case @action
             when :add
-              conf[dev] << config_file_contents(:add, comment: resource.comment, target: resource.target, metric: resource.metric, netmask: resource.netmask, gateway: resource.gateway) if resource.action == [:add]
+              conf[dev] << config_file_contents(:add, comment: resource.comment, device: resource.device, target: resource.target, metric: resource.metric, netmask: resource.netmask, gateway: resource.gateway) if resource.action == [:add]
             when :delete
               # need to do this for the case when the last route on an int
               # is removed
@@ -236,6 +236,7 @@ class Chef
           content << (options[:target]).to_s
           content << "/#{MASK[options[:netmask].to_s]}" if options[:netmask]
           content << " via #{options[:gateway]}" if options[:gateway]
+          content << " dev #{options[:device]}" if options[:device]
           content << " metric #{options[:metric]}" if options[:metric]
           content << "\n"
         end

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

@@ -52,8 +52,8 @@ class Chef
           end
 
           requirements.assert(:all_actions) do |a|
-            a.assertion { @so_priority.exitstatus == 0 }
-            a.failure_message Chef::Exceptions::Service, "/usr/sbin/update-rc.d -f #{current_resource.service_name} failed - #{@so_priority.inspect}"
+            a.assertion { @got_priority == true }
+            a.failure_message Chef::Exceptions::Service, "Unable to determine priority for service"
             # This can happen if the service is not yet installed,so we'll fake it.
             a.whyrun ["Unable to determine priority of service, assuming service would have been correctly installed earlier in the run.",
                       "Assigning temporary priorities to continue.",
@@ -70,22 +70,38 @@ class Chef
           end
         end
 
+        # returns a list of levels that the service should be stopped or started on
+        def parse_init_file(path)
+          return [] unless ::File.exist?(path)
+          in_info = false
+          ::File.readlines(path).each_with_object([]) do |line, acc|
+            if line =~ /^### BEGIN INIT INFO/
+              in_info = true
+            elsif line =~ /^### END INIT INFO/
+              in_info = false
+            elsif in_info
+              if line =~ /Default-(Start|Stop):\s+(\d.*)/
+                acc << $2.split(" ")
+              end
+            end
+          end.flatten
+        end
+
         def get_priority
           priority = {}
+          rc_files = []
 
-          @so_priority = shell_out!("/usr/sbin/update-rc.d -f #{current_resource.service_name} remove")
+          levels = parse_init_file(@init_command)
+          levels.each do |level|
+            rc_files.push Dir.glob("/etc/rc#{level}.d/[SK][0-9][0-9]#{current_resource.service_name}")
+          end
 
-          [@so_priority.stdout, @so_priority.stderr].each do |iop|
-            iop.each_line do |line|
-              if UPDATE_RC_D_PRIORITIES =~ line
-                # priority[runlevel] = [ S|K, priority ]
-                # S = Start, K = Kill
-                # debian runlevels: 0 Halt, 1 Singleuser, 2 Multiuser, 3-5 == 2, 6 Reboot
-                priority[$1] = [($2 == "S" ? :start : :stop), $3]
-              end
-              if line =~ UPDATE_RC_D_ENABLED_MATCHES
-                enabled = true
-              end
+          rc_files.flatten.each do |line|
+            if UPDATE_RC_D_PRIORITIES =~ line
+              # priority[runlevel] = [ S|K, priority ]
+              # S = Start, K = Kill
+              # debian runlevels: 0 Halt, 1 Singleuser, 2 Multiuser, 3-5 == 2, 6 Reboot
+              priority[$1] = [($2 == "S" ? :start : :stop), $3]
             end
           end
 
@@ -95,6 +111,7 @@ class Chef
             priority = priority[2].last
           end
 
+          @got_priority = true
           priority
         end
 

data/lib/chef/provider/windows_task.rb

@@ -20,6 +20,8 @@ require "chef/mixin/shell_out"
 require "rexml/document"
 require "iso8601"
 require "chef/mixin/powershell_out"
+require "chef/provider"
+require "win32/taskscheduler" if Chef::Platform.windows?
 
 class Chef
   class Provider
@@ -27,542 +29,559 @@ class Chef
       include Chef::Mixin::ShellOut
       include Chef::Mixin::PowershellOut
 
-      provides :windows_task
-
-      def load_current_resource
-        self.current_resource = Chef::Resource::WindowsTask.new(new_resource.name)
-        pathed_task_name = new_resource.task_name.start_with?('\\') ? new_resource.task_name : "\\#{new_resource.task_name}"
-
-        current_resource.task_name(pathed_task_name)
-        task_hash = load_task_hash(pathed_task_name)
-
-        set_current_resource(task_hash) if task_hash.respond_to?(:[]) && task_hash[:TaskName] == pathed_task_name
-        current_resource
-      end
-
-      def set_current_resource(task_hash)
-        current_resource.exists = true
-        current_resource.command(task_hash[:TaskToRun])
-        current_resource.cwd(task_hash[:StartIn]) unless task_hash[:StartIn] == "N/A"
-        current_resource.user(task_hash[:RunAsUser])
-        set_current_run_level task_hash[:run_level]
-        set_current_frequency task_hash
-        current_resource.day(task_hash[:day]) if task_hash[:day]
-        current_resource.months(task_hash[:months]) if task_hash[:months]
-        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]
-        # schtask sets execution_time_limit as PT72H by default
-        current_resource.execution_time_limit(task_hash[:execution_time_limit] || "PT72H")
-        current_resource.status = :running if task_hash[:Status] == "Running"
-        current_resource.enabled = true if task_hash[:ScheduledTaskState] == "Enabled"
-        current_resource.start_time = task_hash[:StartTime] if task_hash[:StartTime]
-        current_resource.start_day = task_hash[:StartDate] if task_hash[:StartDate]
-      end
+      if Chef::Platform.windows?
+        include Win32
+
+        provides :windows_task
+
+        MONTHS = {
+          JAN: TaskScheduler::JANUARY,
+          FEB: TaskScheduler::FEBRUARY,
+          MAR: TaskScheduler::MARCH,
+          APR: TaskScheduler::APRIL,
+          MAY: TaskScheduler::MAY,
+          JUN: TaskScheduler::JUNE,
+          JUL: TaskScheduler::JULY,
+          AUG: TaskScheduler::AUGUST,
+          SEP: TaskScheduler::SEPTEMBER,
+          OCT: TaskScheduler::OCTOBER,
+          NOV: TaskScheduler::NOVEMBER,
+          DEC: TaskScheduler::DECEMBER
+        }
 
-      # 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
+        DAYS_OF_WEEK = { MON: TaskScheduler::MONDAY,
+                         TUE: TaskScheduler::TUESDAY,
+                         WED: TaskScheduler::WEDNESDAY,
+                         THU: TaskScheduler::THURSDAY,
+                         FRI: TaskScheduler::FRIDAY,
+                         SAT: TaskScheduler::SATURDAY,
+                         SUN: TaskScheduler::SUNDAY }
+
+        WEEKS_OF_MONTH = {
+          FIRST: TaskScheduler::FIRST_WEEK,
+          SECOND: TaskScheduler::SECOND_WEEK,
+          THIRD: TaskScheduler::THIRD_WEEK,
+          FOURTH: TaskScheduler::FOURTH_WEEK
+        }
 
-      # 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
+        DAYS_OF_MONTH = {
+          1 => TaskScheduler::TASK_FIRST,
+          2 => TaskScheduler::TASK_SECOND,
+          3 => TaskScheduler::TASK_THIRD,
+          4 => TaskScheduler::TASK_FOURTH,
+          5 => TaskScheduler::TASK_FIFTH,
+          6 => TaskScheduler::TASK_SIXTH,
+          7 => TaskScheduler::TASK_SEVENTH,
+          8 => TaskScheduler::TASK_EIGHTH,
+          9 => TaskScheduler::TASK_NINETH,
+          10 => TaskScheduler::TASK_TENTH,
+          11 => TaskScheduler::TASK_ELEVENTH,
+          12 => TaskScheduler::TASK_TWELFTH,
+          13 => TaskScheduler::TASK_THIRTEENTH,
+          14 => TaskScheduler::TASK_FOURTEENTH,
+          15 => TaskScheduler::TASK_FIFTEENTH,
+          16 => TaskScheduler::TASK_SIXTEENTH,
+          17 => TaskScheduler::TASK_SEVENTEENTH,
+          18 => TaskScheduler::TASK_EIGHTEENTH,
+          19 => TaskScheduler::TASK_NINETEENTH,
+          20 => TaskScheduler::TASK_TWENTIETH,
+          21 => TaskScheduler::TASK_TWENTY_FIRST,
+          22 => TaskScheduler::TASK_TWENTY_SECOND,
+          23 => TaskScheduler::TASK_TWENTY_THIRD,
+          24 => TaskScheduler::TASK_TWENTY_FOURTH,
+          25 => TaskScheduler::TASK_TWENTY_FIFTH,
+          26 => TaskScheduler::TASK_TWENTY_SIXTH,
+          27 => TaskScheduler::TASK_TWENTY_SEVENTH,
+          28 => TaskScheduler::TASK_TWENTY_EIGHTH,
+          29 => TaskScheduler::TASK_TWENTY_NINTH,
+          30 => TaskScheduler::TASK_THIRTYETH,
+          31 => TaskScheduler::TASK_THIRTY_FIRST
+        }
 
-      def action_create
-        if current_resource.exists
-          logger.trace "#{new_resource} task exists"
-          if !(task_need_update? || new_resource.force)
-            logger.info "#{new_resource} task does not need updating and force is not specified - nothing to do"
-            return
-          end
-          # 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?
+        def load_current_resource
+          @current_resource = Chef::Resource::WindowsTask.new(new_resource.name)
+          task = TaskScheduler.new
+          if task.exists?(new_resource.task_name)
+            @current_resource.exists = true
+            task.get_task(new_resource.task_name)
+            @current_resource.task = task
+            pathed_task_name = new_resource.task_name.start_with?('\\') ? new_resource.task_name : "\\#{new_resource.task_name}"
+            @current_resource.task_name(pathed_task_name)
+          else
+            @current_resource.exists = false
           end
+          @current_resource
         end
-        basic_validation
-        options = {}
-        options["F"] = "" if new_resource.force || task_need_update?
-        if schedule == :none
-          options["SC"] = :once
-          options["ST"] = "00:00"
-          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? || 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?
-        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
-
-        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
-          logger.trace "#{new_resource} task exists"
-          if current_resource.status == :running
-            logger.info "#{new_resource} task is currently running, skipping run"
+        def action_create
+          if current_resource.exists
+            logger.trace "#{new_resource} task exist."
+            unless (task_needs_update?(current_resource.task)) || (new_resource.force)
+              logger.info "#{new_resource} task does not need updating and force is not specified - nothing to do"
+              return
+            end
+
+            # if start_day and start_time is not set by user current date and time will be set while updating any property
+            set_start_day_and_time unless new_resource.frequency == :none
+            update_task(current_resource.task)
           else
-            converge_by("run scheduled task #{new_resource}") do
-              run_schtasks "RUN"
+            basic_validation
+            set_start_day_and_time
+            converge_by("#{new_resource} task created") do
+              task = TaskScheduler.new
+              if new_resource.frequency == :none
+                task.new_work_item(new_resource.task_name, {})
+                task.activate(new_resource.task_name)
+              else
+                task.new_work_item(new_resource.task_name, trigger)
+              end
+              task.application_name = new_resource.command
+              task.working_directory = new_resource.cwd if new_resource.cwd
+              task.configure_settings(config_settings)
+              task.configure_principals(principal_settings)
+              task.set_account_information(new_resource.user, new_resource.password)
+              task.creator = new_resource.user
+              task.activate(new_resource.task_name)
             end
           end
-        else
-          logger.warn "#{new_resource} task does not exist - nothing to do"
         end
-      end
 
-      def action_delete
-        if current_resource.exists
-          logger.trace "#{new_resource} task exists"
-          converge_by("delete scheduled task #{new_resource}") do
-            # always need to force deletion
-            run_schtasks "DELETE", "F" => ""
+        def action_run
+          if current_resource.exists
+            logger.trace "#{new_resource} task exists"
+            if current_resource.task.status == "running"
+              logger.info "#{new_resource} task is currently running, skipping run"
+            else
+              converge_by("run scheduled task #{new_resource}") do
+                current_resource.task.run
+              end
+            end
+          else
+            logger.warn "#{new_resource} task does not exist - nothing to do"
           end
-        else
-          logger.warn "#{new_resource} task does not exist - nothing to do"
         end
-      end
 
-      def action_end
-        if current_resource.exists
-          logger.trace "#{new_resource} task exists"
-          if current_resource.status != :running
-            logger.trace "#{new_resource} is not running - nothing to do"
-          else
-            converge_by("#{new_resource} task ended") do
-              run_schtasks "END"
+        def action_delete
+          if current_resource.exists
+            logger.trace "#{new_resource} task exists"
+            converge_by("delete scheduled task #{new_resource}") do
+              ts = TaskScheduler.new
+              ts.delete(current_resource.task_name)
             end
+          else
+            logger.warn "#{new_resource} task does not exist - nothing to do"
           end
-        else
-          logger.warn "#{new_resource} task does not exist - nothing to do"
         end
-      end
 
-      def action_enable
-        if current_resource.exists
-          logger.trace "#{new_resource} task exists"
-          if current_resource.enabled
-            logger.trace "#{new_resource} already enabled - nothing to do"
-          else
-            converge_by("#{new_resource} task enabled") do
-              run_schtasks "CHANGE", "ENABLE" => ""
+        def action_end
+          if current_resource.exists
+            logger.trace "#{new_resource} task exists"
+            if current_resource.task.status != "running"
+              logger.trace "#{new_resource} is not running - nothing to do"
+            else
+              converge_by("#{new_resource} task ended") do
+                current_resource.task.stop
+              end
             end
+          else
+            logger.warn "#{new_resource} task does not exist - nothing to do"
           end
-        else
-          logger.fatal "#{new_resource} task does not exist - nothing to do"
-          raise Errno::ENOENT, "#{new_resource}: task does not exist, cannot enable"
         end
-      end
 
-      def action_disable
-        if current_resource.exists
-          logger.info "#{new_resource} task exists"
-          if current_resource.enabled
-            converge_by("#{new_resource} task disabled") do
-              run_schtasks "CHANGE", "DISABLE" => ""
+        def action_enable
+          if current_resource.exists
+            logger.trace "#{new_resource} task exists"
+            if current_resource.task.status == "not scheduled"
+              converge_by("#{new_resource} task enabled") do
+                #TODO wind32-taskscheduler currently not having any method to handle this so using schtasks.exe here
+                run_schtasks "CHANGE", "ENABLE" => ""
+              end
+            else
+              logger.trace "#{new_resource} already enabled - nothing to do"
             end
           else
-            logger.warn "#{new_resource} already disabled - nothing to do"
+            logger.fatal "#{new_resource} task does not exist - nothing to do"
+            raise Errno::ENOENT, "#{new_resource}: task does not exist, cannot enable"
           end
-        else
-          logger.warn "#{new_resource} task does not exist - nothing to do"
         end
-      end
-
-      private
 
-      # rubocop:disable Style/StringLiteralsInInterpolation
-      def run_schtasks(task_action, options = {})
-        cmd = "schtasks /#{task_action} /TN \"#{new_resource.task_name}\" "
-        options.each_key do |option|
-          unless option == "TR"
-            cmd += "/#{option} "
-            cmd += "\"#{options[option].to_s.gsub('"', "\\\"")}\" " unless options[option] == ""
+        def action_disable
+          if current_resource.exists
+            logger.info "#{new_resource} task exists"
+            if %w{ready running}.include?(current_resource.task.status)
+              converge_by("#{new_resource} task disabled") do
+                #TODO: in win32-taskscheduler there is no method whcih disbales the task so currently calling disable with schtasks.exe
+                run_schtasks "CHANGE", "DISABLE" => ""
+              end
+            else
+              logger.warn "#{new_resource} already disabled - nothing to do"
+            end
+          else
+            logger.warn "#{new_resource} task does not exist - nothing to do"
           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
-        logger.trace("running: ")
-        logger.trace("    #{cmd}")
-        shell_out!(cmd, returns: [0])
-      end
-      # rubocop:enable Style/StringLiteralsInInterpolation
-
-      def task_need_update?
-        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 ||
-            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
-        rescue
-          logger.trace "caught a raise in task_needs_update?"
-        end
 
-        false
-      end
+        alias_method :action_change, :action_create
 
-      # 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
+        private
 
-      # 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)
+        def set_start_day_and_time
+          new_resource.start_day = Time.now.strftime("%m/%d/%Y") unless new_resource.start_day
+          new_resource.start_time = Time.now.strftime("%H:%M") unless new_resource.start_time
         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)
-        current_day != new_day
-      end
-
-      def start_time_updated?
-        time = DateTime.parse(current_resource.start_time).strftime("%H:%M")
-        time != new_resource.start_time
-      end
+        def update_task(task)
+          converge_by("#{new_resource} task updated") do
+            task.set_account_information(new_resource.user, new_resource.password)
+            task.application_name = new_resource.command if new_resource.command
+            task.working_directory = new_resource.cwd if new_resource.cwd
+            task.trigger = trigger unless new_resource.frequency == :none
+            task.configure_settings(config_settings)
+            task.creator = new_resource.user
+            task.configure_principals(principal_settings)
+          end
+        end
 
-      def convert_user_date_to_system_date(date_in_string)
-        parse_day(date_in_string).strftime(convert_system_date_format_to_ruby_long_date)
-      end
+        def trigger
+          start_month, start_day, start_year = new_resource.start_day.to_s.split("/")
+          start_hour, start_minute = new_resource.start_time.to_s.split(":")
+          #TODO currently end_month, end_year and end_year needs to be set to 0. If not set win32-taskscheduler throwing nil into integer error.
+          trigger_hash = {
+            start_year: start_year.to_i,
+            start_month: start_month.to_i,
+            start_day: start_day.to_i,
+            start_hour: start_hour.to_i,
+            start_minute: start_minute.to_i,
+            end_month: 0,
+            end_day: 0,
+            end_year: 0,
+            trigger_type: trigger_type,
+            type: type,
+            random_minutes_interval: new_resource.random_delay
+          }
+
+          if new_resource.frequency == :minute
+            trigger_hash[:minutes_interval] = new_resource.frequency_modifier
+          end
 
-      def convert_system_date_format_to_ruby_long_date
-        date_format = get_system_short_date_format.dup
-        date_format.sub!("MMM", "%m")
-        common_date_format_conversion(date_format)
-        date_format.sub!("yy", "%Y")
-        date_format
-      end
+          if new_resource.frequency == :hourly
+            minutes = convert_hours_in_minutes(new_resource.frequency_modifier.to_i)
+            trigger_hash[:minutes_interval] = minutes
+          end
 
-      def convert_system_date_format_to_ruby_date_format
-        date_format = get_system_short_date_format.dup
-        date_format.sub!("MMM", "%b")
-        common_date_format_conversion(date_format)
-        date_format.sub!("yy", "%y")
-        date_format
-      end
+          if new_resource.minutes_interval
+            trigger_hash[:minutes_interval] = new_resource.minutes_interval
+          end
 
-      def common_date_format_conversion(date_format)
-        date_format.sub!("dd", "d")
-        date_format.sub!("d", "%d")
-        date_format.sub!("MM", "%m")
-        date_format.sub!("M", "%m")
-        date_format.sub!("yyyy", "%Y")
-      end
+          if new_resource.minutes_duration
+            trigger_hash[:minutes_duration] = new_resource.minutes_duration
+          end
 
-      def get_system_short_date_format
-        return @system_short_date_format if @system_short_date_format
-        logger.trace "Finding system date format"
-        task_script = <<-EOH
-          [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
-          [Globalization.Cultureinfo]::CurrentCulture.DateTimeFormat.ShortDatePattern
-        EOH
-        @system_short_date_format = powershell_out(task_script).stdout.force_encoding("UTF-8").gsub(/[\s+\uFEFF]/, "")
-        @system_short_date_format
-      end
+          if trigger_type == TaskScheduler::MONTHLYDOW && frequency_modifier_contains_last_week?(new_resource.frequency_modifier)
+            trigger_hash[:run_on_last_week_of_month] = true
+          else
+            trigger_hash[:run_on_last_week_of_month] = false
+          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")
+          if trigger_type == TaskScheduler::MONTHLYDATE && day_includes_last_or_lastday?(new_resource.day)
+            trigger_hash[:run_on_last_day_of_month] = true
+          else
+            trigger_hash[:run_on_last_day_of_month] = false
+          end
+          trigger_hash
         end
-        system_date
-      end
 
-      def update_task_xml(options = [])
-        # random_delay xml element is different for different frequencies
-        random_delay_xml_element = {
-          :minute => "Triggers/TimeTrigger/RandomDelay",
-          :hourly => "Triggers/TimeTrigger/RandomDelay",
-          :once => "Triggers/TimeTrigger/RandomDelay",
-          :daily => "Triggers/CalendarTrigger/RandomDelay",
-          :weekly => "Triggers/CalendarTrigger/RandomDelay",
-          :monthly => "Triggers/CalendarTrigger/RandomDelay",
-          :none => "Triggers",
-        }
-
-        xml_element_mapping = {
-          "cwd" => "Actions/Exec/WorkingDirectory",
-          "random_delay" => random_delay_xml_element[new_resource.frequency],
-          "execution_time_limit" => "Settings/ExecutionTimeLimit",
-        }
+        def frequency_modifier_contains_last_week?(frequency_modifier)
+          frequency_modifier = frequency_modifier.to_s.split(",")
+          frequency_modifier.map! { |value| value.strip.upcase }
+          frequency_modifier.include?("LAST")
+        end
 
-        logger.trace "looking for existing tasks"
+        def day_includes_last_or_lastday?(day)
+          day = day.to_s.split(",")
+          day.map! { |value| value.strip.upcase }
+          day.include?("LAST") || day.include?("LASTDAY")
+        end
 
-        task_script = <<-EOH
-            [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
-            schtasks /Query /TN \"#{new_resource.task_name}\" /XML
-        EOH
-        xml_cmd = powershell_out(task_script)
+        def convert_hours_in_minutes(hours)
+          hours.to_i * 60 if hours
+        end
 
-        return if xml_cmd.exitstatus != 0
+        #TODO : Try to optimize this method
+        # known issue : Since start_day and time is not mandatory while updating weekly frequency for which start_day is not mentioned by user idempotency
+        # is not gettting maintained as new_resource.start_day is nil and we fetch the day of week from start_day to set and its currently coming as nil and don't match with current_task
+        def task_needs_update?(task)
+          flag = false
+          if new_resource.frequency == :none
+            flag = (task.account_information != new_resource.user ||
+            task.application_name != new_resource.command ||
+            task.principals[:run_level] != run_level)
+          else
+            current_task_trigger = task.trigger(0)
+            new_task_trigger = trigger
+            flag = (ISO8601::Duration.new(task.idle_settings[:idle_duration])) != (ISO8601::Duration.new(new_resource.idle_time * 60)) if new_resource.frequency == :on_idle
+            flag = (ISO8601::Duration.new(task.execution_time_limit)) != (ISO8601::Duration.new(new_resource.execution_time_limit * 60)) unless new_resource.execution_time_limit.nil?
+
+            # if trigger not found updating the task to add the trigger
+            if current_task_trigger.nil?
+              flag = true
+            else
+              flag = true if start_day_updated?(current_task_trigger, new_task_trigger) == true ||
+                  start_time_updated?(current_task_trigger, new_task_trigger) == true ||
+                  current_task_trigger[:trigger_type] != new_task_trigger[:trigger_type] ||
+                  current_task_trigger[:type] != new_task_trigger[:type] ||
+                  current_task_trigger[:random_minutes_interval].to_i != new_task_trigger[:random_minutes_interval].to_i ||
+                  current_task_trigger[:minutes_interval].to_i != new_task_trigger[:minutes_interval].to_i ||
+                  task.account_information != new_resource.user ||
+                  task.application_name != new_resource.command ||
+                  task.working_directory != new_resource.cwd.to_s ||
+                  task.principals[:logon_type] != logon_type ||
+                  task.principals[:run_level] != run_level
+
+              if trigger_type == TaskScheduler::MONTHLYDATE
+                flag = true if current_task_trigger[:run_on_last_day_of_month] != new_task_trigger[:run_on_last_day_of_month]
+              end
+
+              if trigger_type == TaskScheduler::MONTHLYDOW
+                flag = true if current_task_trigger[:run_on_last_week_of_month] != new_task_trigger[:run_on_last_week_of_month]
+              end
+            end
+          end
+          flag
+        end
 
-        doc = REXML::Document.new(xml_cmd.stdout)
+        def start_day_updated?(current_task_trigger, new_task_trigger)
+          ( new_resource.start_day && (current_task_trigger[:start_year].to_i != new_task_trigger[:start_year] ||
+                    current_task_trigger[:start_month].to_i != new_task_trigger[:start_month] ||
+                    current_task_trigger[:start_day].to_i != new_task_trigger[:start_day]) )
+        end
 
-        if new_resource.frequency == :none
-          doc.root.elements.delete(xml_element_mapping["random_delay"])
-          trigger_element = REXML::Element.new(xml_element_mapping["random_delay"])
-          doc.root.elements.add(trigger_element)
+        def start_time_updated?(current_task_trigger, new_task_trigger)
+          ( new_resource.start_time && ( current_task_trigger[:start_hour].to_i != new_task_trigger[:start_hour] ||
+            current_task_trigger[:start_minute].to_i != new_task_trigger[:start_minute] ) )
         end
 
-        options.each do |option|
-          logger.trace "Removing former #{option} if any"
-          doc.root.elements.delete(xml_element_mapping[option])
-          option_value = new_resource.send("#{option}")
-
-          if option_value
-            logger.trace "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)
-            cwd_element.add_text(option_value)
-            element_root = (split_xml_path - [element_name]).join("/") # element_root = 'Actions/Exec'
-            exec_element = doc.root.elements[element_root]
-            exec_element.add_element(cwd_element)
+        def trigger_type
+          case new_resource.frequency
+            when :once, :minute, :hourly
+              TaskScheduler::ONCE
+            when :daily
+              TaskScheduler::DAILY
+            when :weekly
+              TaskScheduler::WEEKLY
+            when :monthly
+              # If frequency modifier is set with frequency :monthly we are setting taskscheduler as monthlydow
+              # Ref https://msdn.microsoft.com/en-us/library/windows/desktop/aa382061(v=vs.85).aspx
+              new_resource.frequency_modifier.to_i.between?(1, 12) ? TaskScheduler::MONTHLYDATE : TaskScheduler::MONTHLYDOW
+            when :on_idle
+              TaskScheduler::ON_IDLE
+            when :onstart
+              TaskScheduler::AT_SYSTEMSTART
+            when :on_logon
+              TaskScheduler::AT_LOGON
+            else
+              raise ArgumentError, "Please set frequency"
           end
         end
 
-        temp_task_file = ::File.join(ENV["TEMP"], "windows_task.xml")
-        begin
-          ::File.open(temp_task_file, "w:UTF-16LE") do |f|
-            doc.write(f)
+        def type
+          case trigger_type
+            when TaskScheduler::ONCE
+              { once: nil }
+            when TaskScheduler::DAILY
+              { days_interval: new_resource.frequency_modifier.to_i }
+            when TaskScheduler::WEEKLY
+              { weeks_interval: new_resource.frequency_modifier.to_i, days_of_week: days_of_week.to_i }
+            when TaskScheduler::MONTHLYDATE
+              { months: months_of_year.to_i, days: days_of_month.to_i }
+            when TaskScheduler::MONTHLYDOW
+              { months: months_of_year.to_i, days_of_week: days_of_week.to_i, weeks_of_month: weeks_of_month.to_i }
+            when TaskScheduler::ON_IDLE
+              # TODO: handle option for this trigger
+            when TaskScheduler::AT_LOGON
+              # TODO: handle option for this trigger
+            when TaskScheduler::AT_SYSTEMSTART
+              # TODO: handle option for this trigger
           end
+        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["XML"] = temp_task_file
-          run_schtasks("DELETE", "F" => "")
-          run_schtasks("CREATE", options)
-        ensure
-          ::File.delete(temp_task_file)
+        # Deleting last from the array of weeks of month since last week is handled in :run_on_last_week_of_month parameter.
+        def weeks_of_month
+          weeks_of_month = []
+          if new_resource.frequency_modifier
+            weeks = new_resource.frequency_modifier.split(",")
+            weeks.map! { |week| week.to_s.strip.upcase }
+            weeks.delete("LAST") if weeks.include?("LAST")
+            weeks_of_month = get_binary_values_from_constants(weeks, WEEKS_OF_MONTH)
+          end
+          weeks_of_month
         end
-      end
 
-      def load_task_hash(task_name)
-        logger.trace "Looking for existing tasks"
-
-        task_script = <<-EOH
-          [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
-          schtasks /Query /FO LIST /V /TN \"#{task_name}\"
-        EOH
-
-        output = powershell_out(task_script).stdout.force_encoding("UTF-8")
-        if output.empty?
-          task = false
-        else
-          task = {}
-
-          output.split("\n").map! do |line|
-            line.split(": ").map!(&:strip)
-          end.each do |field|
-            if field.is_a?(Array) && field[0].respond_to?(:to_sym)
-              key = (field - [field.last]).join(": ")
-              task[key.gsub(/\s+/, "").to_sym] = field.last
+        # Deleting the "LAST" and "LASTDAY" from days since last day is handled in :run_on_last_day_of_month parameter.
+        def days_of_month
+          days_of_month = []
+          if new_resource.day
+            days = new_resource.day.split(",")
+            days.map! { |day| day.to_s.strip.upcase }
+            days.delete("LAST") if days.include?("LAST")
+            days.delete("LASTDAY") if days.include?("LASTDAY")
+            if days - (1..31).to_a
+              days.each do |day|
+                days_of_month << DAYS_OF_MONTH[day.to_i]
+              end
+              days_of_month = days_of_month.size > 1 ? days_of_month.inject(:|) : days_of_month[0]
             end
+          else
+            days_of_month = DAYS_OF_MONTH[1]
           end
+          days_of_month
         end
 
-        task_xml = load_task_xml task_name
-        task.merge!(task_xml) if task && task_xml
-
-        task
-      end
-
-      def load_task_xml(task_name)
-        task_script = <<-EOH
-            [Console]::OutputEncoding = [Text.UTF8Encoding]::UTF8
-            schtasks /Query /TN \"#{task_name}\" /XML
-        EOH
-        xml_cmd = powershell_out(task_script)
-
-        return if xml_cmd.exitstatus != 0
-
-        doc = REXML::Document.new(xml_cmd.stdout)
-        root = doc.root
-
-        task = {}
-        task[:run_level] = root.elements["Principals/Principal/RunLevel"].text if root.elements["Principals/Principal/RunLevel"]
-
-        # for frequency = :minutes, :hourly
-        task[:repetition_interval] = root.elements["Triggers/TimeTrigger/Repetition/Interval"].text if root.elements["Triggers/TimeTrigger/Repetition/Interval"]
+        def days_of_week
+          if new_resource.day
+            #this line of code is just to support backward compatibility of wild card *
+            new_resource.day = "mon, tue, wed, thu, fri, sat, sun" if new_resource.day == "*" && new_resource.frequency == :weekly
+            days = new_resource.day.split(",")
+            days.map! { |day| day.to_s.strip.upcase }
+            weeks_days = get_binary_values_from_constants(days, DAYS_OF_WEEK)
+          else
+            # following condition will make the frequency :weekly idempotent if start_day is not provided by user setting day as the current_resource day
+            if (current_resource) && (current_resource.task) && (current_resource.task.trigger(0)[:type][:days_of_week]) && (new_resource.start_day.nil?)
+              weeks_days = current_resource.task.trigger(0)[:type][:days_of_week]
+            else
+              day = get_day(new_resource.start_day).to_sym if new_resource.start_day
+              DAYS_OF_WEEK[day]
+            end
+          end
+        end
 
-        # for frequency = :daily
-        task[:schedule_by_day] = root.elements["Triggers/CalendarTrigger/ScheduleByDay/DaysInterval"].text if root.elements["Triggers/CalendarTrigger/ScheduleByDay/DaysInterval"]
+        def months_of_year
+          months_of_year = []
+          if new_resource.frequency_modifier.to_i.between?(1, 12) && !(new_resource.months)
+            new_resource.months = set_months(new_resource.frequency_modifier.to_i)
+          end
 
-        # for frequency = :weekly
-        task[:schedule_by_week] = root.elements["Triggers/CalendarTrigger/ScheduleByWeek/WeeksInterval"].text if root.elements["Triggers/CalendarTrigger/ScheduleByWeek/WeeksInterval"]
-        if root.elements["Triggers/CalendarTrigger/ScheduleByWeek/DaysOfWeek"]
-          task[:day] = []
-          root.elements["Triggers/CalendarTrigger/ScheduleByWeek/DaysOfWeek"].elements.each do |e|
-            task[:day] << e.to_s[0..3].delete("<").delete("/>")
+          if new_resource.months
+            #this line of code is just to support backward compatibility of wild card *
+            new_resource.months = "jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec" if new_resource.months == "*" && new_resource.frequency == :monthly
+            months = new_resource.months.split(",")
+            months.map! { |month| month.to_s.strip.upcase }
+            months_of_year = get_binary_values_from_constants(months, MONTHS)
+          else
+            MONTHS.each do |key, value|
+              months_of_year << MONTHS[key]
+            end
+            months_of_year = months_of_year.inject(:|)
           end
-          task[:day] = task[:day].join(", ")
+          months_of_year
         end
 
-        # for frequency = :monthly
-        task[:schedule_by_month] = root.elements["Triggers/CalendarTrigger/ScheduleByMonth/DaysOfMonth/Day"].text if root.elements["Triggers/CalendarTrigger/ScheduleByMonth/DaysOfMonth/Day"]
-        if root.elements["Triggers/CalendarTrigger/ScheduleByMonth/Months"]
-          task[:months] = []
-          root.elements["Triggers/CalendarTrigger/ScheduleByMonth/Months"].elements.each do |e|
-            task[:months] << e.to_s[0..3].delete("<").delete("/>")
+        # This values are set for frequency_modifier set as 1-12
+        # This is to give backward compatibility validated this values with earlier code and running schtask.exe
+        # Used this as reference https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/schtasks#d-dayday--
+        def set_months(frequency_modifier)
+          case frequency_modifier
+            when 1
+              "jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec"
+            when 2
+              "feb, apr, jun, aug, oct, dec"
+            when 3
+              "mar, jun, sep, dec"
+            when 4
+              "apr, aug, dec"
+            when 5
+              "may, oct"
+            when 6
+              "jun, dec"
+            when 7
+              "jul"
+            when 8
+              "aug"
+            when 9
+              "sep"
+            when 10
+              "oct"
+            when 11
+              "nov"
+            when 12
+              "dec"
           end
-          task[:months] = task[:months].join(", ")
         end
 
-        task[:on_logon] = true if root.elements["Triggers/LogonTrigger"]
-        task[:onstart] = true if root.elements["Triggers/BootTrigger"]
-        task[:on_idle] = true if root.elements["Triggers/IdleTrigger"]
-
-        task[:idle_time] = root.elements["Settings/IdleSettings/Duration"].text if root.elements["Settings/IdleSettings/Duration"] && task[:on_idle]
-
-        task[:none] = true if root.elements["Triggers/"] && root.elements["Triggers/"].entries.empty?
-        task[:once] = true if !(task[:repetition_interval] || task[:schedule_by_day] || task[:schedule_by_week] || task[:schedule_by_month] || task[:on_logon] || task[:onstart] || task[:on_idle] || task[:none])
-        task[:execution_time_limit] = root.elements["Settings/ExecutionTimeLimit"].text if root.elements["Settings/ExecutionTimeLimit"] #by default PT72H
-        task[:random_delay] = root.elements["Triggers/TimeTrigger/RandomDelay"].text if root.elements["Triggers/TimeTrigger/RandomDelay"]
-        task[:random_delay] = root.elements["Triggers/CalendarTrigger/RandomDelay"].text if root.elements["Triggers/CalendarTrigger/RandomDelay"]
-        task
-      end
-
-      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)
-      end
-
-      def schedule
-        case new_resource.frequency
-        when :on_logon
-          "ONLOGON"
-        when :on_idle
-          "ONIDLE"
-        else
-          new_resource.frequency
+        def get_binary_values_from_constants(array_values, constant)
+          data = []
+          array_values.each do |value|
+            value = value.to_sym
+            data << constant[value]
+          end
+          data.size > 1 ? data.inject(:|) : data[0]
         end
-      end
 
-      def frequency_modifier_allowed
-        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)
-        else
-          false
+        def run_level
+          case new_resource.run_level
+          when :highest
+            TaskScheduler::TASK_RUNLEVEL_HIGHEST
+          when :limited
+            TaskScheduler::TASK_RUNLEVEL_LUA
+          end
         end
-      end
 
-      def set_current_run_level(run_level)
-        case run_level
-        when "HighestAvailable"
-          current_resource.run_level(:highest)
-        when "LeastPrivilege"
-          current_resource.run_level(:limited)
+        #TODO: while creating the configuration settings win32-taskscheduler it accepts execution time limit values in ISO8601 formata
+        def config_settings
+          settings = {
+            execution_time_limit: new_resource.execution_time_limit,
+            enabled: true
+          }
+          settings[:idle_duration] = new_resource.idle_time if new_resource.idle_time
+          settings[:run_only_if_idle] = true if new_resource.idle_time
+          settings
         end
-      end
 
-      def set_current_frequency(task_hash)
-        if task_hash[:repetition_interval]
-          duration = ISO8601::Duration.new(task_hash[:repetition_interval])
-          if task_hash[:repetition_interval].include?("M")
-            current_resource.frequency(:minute)
-            current_resource.frequency_modifier(duration.minutes.atom.to_i)
-          elsif task_hash[:repetition_interval].include?("H")
-            current_resource.frequency(:hourly)
-            current_resource.frequency_modifier(duration.hours.atom.to_i)
-          end
+        def principal_settings
+          settings = {}
+          settings [:run_level] = run_level
+          settings[:logon_type] = logon_type
+          settings
         end
 
-        if task_hash[:schedule_by_day]
-          current_resource.frequency(:daily)
-          current_resource.frequency_modifier(task_hash[:schedule_by_day].to_i)
+        def logon_type
+          # Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/aa383566(v=vs.85).aspx
+          # if nothing is passed as logon_type the TASK_LOGON_SERVICE_ACCOUNT is getting set as default so using that for comparision.
+          new_resource.password.nil? ? TaskScheduler::TASK_LOGON_SERVICE_ACCOUNT : TaskScheduler::TASK_LOGON_PASSWORD
         end
 
-        if task_hash[:schedule_by_week]
-          current_resource.frequency(:weekly)
-          current_resource.frequency_modifier(task_hash[:schedule_by_week].to_i)
+        # 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
 
-        current_resource.frequency(:monthly) if task_hash[:schedule_by_month]
-        current_resource.frequency(:on_logon) if task_hash[:on_logon]
-        current_resource.frequency(:onstart) if task_hash[:onstart]
-        current_resource.frequency(:on_idle) if task_hash[:on_idle]
-        current_resource.frequency(:once) if task_hash[:once]
-        current_resource.frequency(:none) if task_hash[:none]
-      end
-
-      def set_current_idle_time(idle_time)
-        duration = ISO8601::Duration.new(idle_time)
-        current_resource.idle_time(duration.minutes.atom.to_i)
-      end
+        # rubocop:disable Style/StringLiteralsInInterpolation
+        def run_schtasks(task_action, options = {})
+          cmd = "schtasks /#{task_action} /TN \"#{new_resource.task_name}\" "
+          options.each_key do |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
+          logger.trace("running: ")
+          logger.trace("    #{cmd}")
+          shell_out!(cmd, returns: [0])
+        end
+        # rubocop:enable Style/StringLiteralsInInterpolation
 
-      def parse_day(str)
-        Date.strptime(str, "%m/%d/%Y")
+        def get_day(date)
+          Date.strptime(date, "%m/%d/%Y").strftime("%a").upcase
+        end
       end
-
     end
   end
 end