chef 13.5.3 → 13.6.0

data/lib/chef/provider/package/dnf/python_helper.rb

@@ -61,6 +61,15 @@ class Chef
             start if stdin.nil?
           end
 
+          def compare_versions(version1, version2)
+            with_helper do
+              json = build_version_query("versioncompare", [version1, version2])
+              Chef::Log.debug "sending '#{json}' to python helper"
+              stdin.syswrite json + "\n"
+              stdout.sysread(4096).chomp.to_i
+            end
+          end
+
           # @returns Array<Version>
           def query(action, provides, version = nil, arch = nil)
             with_helper do
@@ -109,6 +118,12 @@ class Chef
             FFI_Yajl::Encoder.encode(hash)
           end
 
+          def build_version_query(action, versions)
+            hash = { "action" => action }
+            hash["versions"] = versions
+            FFI_Yajl::Encoder.encode(hash)
+          end
+
           def parse_response(output)
             array = output.split.map { |x| x == "nil" ? nil : x }
             array.each_slice(3).map { |x| Version.new(*x) }.first

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

@@ -18,6 +18,7 @@
 require "chef/provider/package"
 require "chef/resource/package"
 require "chef/mixin/get_source_from_package"
+require "chef/provider/package/yum/rpm_utils"
 
 class Chef
   class Provider
@@ -109,6 +110,10 @@ class Chef
 
         private
 
+        def version_compare(v1, v2)
+          Chef::Provider::Package::Yum::RPMVersion.parse(v1) <=> Chef::Provider::Package::Yum::RPMVersion.parse(v2)
+        end
+
         def uri_scheme?(str)
           scheme = URI.split(str).first
           return false unless scheme

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

@@ -165,6 +165,10 @@ class Chef
         #
         # @return [Boolean] true if new_version is equal to or included in current_version
         def target_version_already_installed?(current_version, new_version)
+          version_equals?(current_version, new_version)
+        end
+
+        def version_equals?(current_version, new_version)
           Chef::Log.debug("Checking if #{new_resource} version '#{new_version}' is already installed. #{current_version} is currently installed")
           if current_version.is_a?(Array)
             current_version.include?(new_version)
@@ -179,6 +183,17 @@ class Chef
 
         private
 
+        def version_compare(v1, v2)
+          if v1 == "latest" || v2 == "latest"
+            return 0
+          end
+
+          gem_v1 = Gem::Version.new(v1)
+          gem_v2 = Gem::Version.new(v2)
+
+          gem_v1 <=> gem_v2
+        end
+
         def uninstall_registry_entries
           @uninstall_registry_entries ||= Chef::Provider::Package::Windows::RegistryUninstallEntry.find_entries(new_resource.package_name)
         end

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

@@ -156,26 +156,6 @@ class Chef
           yum_command("-d0 -e0 -y#{expand_options(new_resource.options)} versionlock delete #{unlock_str}")
         end
 
-        # Keep upgrades from trying to install an older candidate version. Can happen when a new
-        # version is installed then removed from a repository, now the older available version
-        # shows up as a viable install candidate.
-        #
-        # Can be done in upgrade_package but an upgraded from->to log message slips out
-        #
-        # Hacky - better overall solution? Custom compare in Package provider?
-        def action_upgrade
-          # Could be uninstalled or have no candidate
-          if current_resource.version.nil? || !candidate_version_array.any?
-            super
-          elsif candidate_version_array.zip(current_version_array).any? do |c, i|
-                  RPMVersion.parse(c) > RPMVersion.parse(i)
-                end
-            super
-          else
-            Chef::Log.debug("#{new_resource} is at the latest version - nothing to do")
-          end
-        end
-
         private
 
         #
@@ -190,6 +170,10 @@ class Chef
             end
         end
 
+        def version_compare(v1, v2)
+          RPMVersion.parse(v1) <=> RPMVersion.parse(v2)
+        end
+
         # Enable or disable YumCache extra_repo_control
         def manage_extra_repo_control
           if new_resource.options

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

@@ -103,7 +103,7 @@ class Chef
         end
 
         def install_package(name, version)
-          zypper_package("install", *options, "--auto-agree-with-licenses", name, version)
+          zypper_package("install", *options, "--auto-agree-with-licenses", allow_downgrade, name, version)
         end
 
         def upgrade_package(name, version)
@@ -147,6 +147,10 @@ class Chef
         def gpg_checks
           "--no-gpg-checks" unless new_resource.gpg_check
         end
+
+        def allow_downgrade
+          "--oldpackage" if new_resource.allow_downgrade
+        end
       end
     end
   end

data/lib/chef/provider/route.rb

@@ -186,7 +186,7 @@ class Chef
               network_file_name = "/etc/sysconfig/network"
               converge_by("write route default route to #{network_file_name}") do
                 Chef::Log.debug("#{new_resource} writing default route #{new_resource.gateway} to #{network_file_name}")
-                if ::File.exists?(network_file_name)
+                if ::File.exist?(network_file_name)
                   network_file = ::Chef::Util::FileEdit.new(network_file_name)
                   network_file.search_file_replace_line /^GATEWAY=/, "GATEWAY=#{new_resource.gateway}"
                   network_file.insert_line_if_no_match /^GATEWAY=/, "GATEWAY=#{new_resource.gateway}"

data/lib/chef/provider/windows_task.rb

@@ -89,11 +89,17 @@ class Chef
         basic_validation
         options = {}
         options["F"] = "" if new_resource.force || task_need_update?
-        options["SC"] = schedule
+        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?
+          options["SD"] = convert_user_date_to_system_date new_resource.start_day unless new_resource.start_day.nil?
+        end
         options["MO"] = new_resource.frequency_modifier if frequency_modifier_allowed
         options["I"]  = new_resource.idle_time unless new_resource.idle_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?
         options["TR"] = new_resource.command
         options["RU"] = new_resource.user
         options["RP"] = new_resource.password if use_password?
@@ -277,6 +283,7 @@ class Chef
           :daily => "Triggers/CalendarTrigger/RandomDelay",
           :weekly => "Triggers/CalendarTrigger/RandomDelay",
           :monthly => "Triggers/CalendarTrigger/RandomDelay",
+          :none => "Triggers",
         }
 
         xml_element_mapping = {
@@ -297,6 +304,12 @@ class Chef
 
         doc = REXML::Document.new(xml_cmd.stdout)
 
+        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)
+        end
+
         options.each do |option|
           Chef::Log.debug 'Removing former #{option} if any'
           doc.root.elements.delete(xml_element_mapping[option])
@@ -410,7 +423,8 @@ class Chef
 
         task[:idle_time] = root.elements["Settings/IdleSettings/Duration"].text if root.elements["Settings/IdleSettings/Duration"] && task[:on_idle]
 
-        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] = 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"]
@@ -481,6 +495,7 @@ class Chef
         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)

data/lib/chef/provider/zypper_repository.rb

@@ -18,24 +18,25 @@
 
 require "chef/resource"
 require "chef/dsl/declare_resource"
-require "chef/mixin/which"
 require "chef/provider/noop"
+require "chef/mixin/shell_out"
 require "shellwords"
 
 class Chef
   class Provider
     class ZypperRepository < Chef::Provider
-
-      extend Chef::Mixin::Which
-
-      provides :zypper_repository do
-        which "zypper"
-      end
+      provides :zypper_repository, platform_family: "suse"
 
       def load_current_resource
       end
 
       action :create do
+        if new_resource.gpgautoimportkeys
+          install_gpg_key(new_resource.gpgkey)
+        else
+          Chef::Log.debug("'gpgautoimportkeys' property is set to false. Skipping key import.")
+        end
+
         declare_resource(:template, "/etc/zypp/repos.d/#{escaped_repo_name}.repo") do
           if template_available?(new_resource.source)
             source new_resource.source
@@ -51,14 +52,14 @@ class Chef
       end
 
       action :delete do
-        declare_resource(:execute, "zypper removerepo #{escaped_repo_name}") do
-          only_if "zypper lr #{escaped_repo_name}"
+        declare_resource(:execute, "zypper --quiet --non-interactive removerepo #{escaped_repo_name}") do
+          only_if "zypper --quiet lr #{escaped_repo_name}"
         end
       end
 
       action :refresh do
-        declare_resource(:execute, "zypper#{' --gpg-auto-import-keys' if new_resource.gpgautoimportkeys} --quiet --no-confirm refresh --force #{escaped_repo_name}") do
-          only_if "zypper lr #{escaped_repo_name}"
+        declare_resource(:execute, "zypper --quiet --non-interactive refresh --force #{escaped_repo_name}") do
+          only_if "zypper --quiet lr #{escaped_repo_name}"
         end
       end
 
@@ -66,14 +67,101 @@ class Chef
       alias_method :action_remove, :action_delete
 
       # zypper repos are allowed to have spaces in the names
+      # @return [String] escaped repo string
       def escaped_repo_name
         Shellwords.escape(new_resource.repo_name)
       end
 
+      # return the specified cookbook name or the cookbook containing the
+      # resource.
+      #
+      # @return [String] name of the cookbook
+      def cookbook_name
+        new_resource.cookbook || new_resource.cookbook_name
+      end
+
+      # determine if a template file is available in the current run
+      # @param [String] path the path to the template file
+      #
+      # @return [Boolean] template file exists or doesn't
       def template_available?(path)
-        !path.nil? && run_context.has_template_in_cookbook?(new_resource.cookbook_name, path)
+        !path.nil? && run_context.has_template_in_cookbook?(cookbook_name, path)
+      end
+
+      # determine if a cookbook file is available in the run
+      # @param [String] path the path to the template file
+      #
+      # @return [Boolean] cookbook file exists or doesn't
+      def has_cookbook_file?(fn)
+        run_context.has_cookbook_file_in_cookbook?(cookbook_name, fn)
+      end
+
+      # Given the provided key URI determine what kind of chef resource we need
+      # to fetch the key
+      # @param [String] uri the uri of the gpg key (local path or http URL)
+      #
+      # @raise [Chef::Exceptions::FileNotFound] Key isn't remote or found in the current run
+      #
+      # @return [Symbol] :remote_file or :cookbook_file
+      def key_type(uri)
+        if uri.start_with?("http")
+          Chef::Log.debug("Will use :remote_file resource to cache the gpg key locally")
+          :remote_file
+        elsif has_cookbook_file?(uri)
+          Chef::Log.debug("Will use :cookbook_file resource to cache the gpg key locally")
+          :cookbook_file
+        else
+          raise Chef::Exceptions::FileNotFound, "Cannot determine location of gpgkey. Must start with 'http' or be a file managed by Chef."
+        end
       end
 
+      # is the provided key already installed
+      # @param [String] key_path the path to the key on the local filesystem
+      #
+      # @return [boolean] is the key already known by rpm
+      def key_installed?(key_path)
+        so = shell_out("rpm -qa gpg-pubkey*")
+        # expected output & match: http://rubular.com/r/RdF7EcXEtb
+        status = /gpg-pubkey-#{key_fingerprint(key_path)}/.match(so.stdout)
+        Chef::Log.debug("GPG key at #{key_path} is known by rpm? #{status ? "true" : "false"}")
+        status
+      end
+
+      # extract the gpg key fingerprint from a local file
+      # @param [String] key_path the path to the key on the local filesystem
+      #
+      # @return [String] the fingerprint of the key
+      def key_fingerprint(key_path)
+        so = shell_out!("gpg --with-fingerprint #{key_path}")
+        # expected output and match: http://rubular.com/r/BpfMjxySQM
+        fingerprint = /pub\s*\S*\/(\S*)/.match(so.stdout)[1].downcase
+        Chef::Log.debug("GPG fingerprint of key at #{key_path} is #{fingerprint}")
+        fingerprint
+      end
+
+      # install the provided gpg key
+      # @param [String] uri the uri of the local or remote gpg key
+      def install_gpg_key(uri)
+        unless uri
+          Chef::Log.debug("'gpgkey' property not provided or set to nil. Skipping key import.")
+          return
+        end
+
+        cached_keyfile = ::File.join(Chef::Config[:file_cache_path], uri.split("/")[-1])
+
+        declare_resource(key_type(new_resource.gpgkey), cached_keyfile) do
+          source uri
+          mode "0644"
+          sensitive new_resource.sensitive
+          action :create
+        end
+
+        declare_resource(:execute, "import gpg key from #{new_resource.gpgkey}") do
+          command "/bin/rpm --import #{cached_keyfile}"
+          not_if { key_installed?(cached_keyfile) }
+          action :run
+        end
+      end
     end
   end
 end

data/lib/chef/resource/deploy.rb

@@ -84,6 +84,12 @@ class Chef
         @checkout_branch = "deploy"
       end
 
+      # This resource is deprecated.
+      def after_created
+        Chef.deprecated(:deploy_resource, "The #{resource_name} resource (#{source_line}) is deprecated and will be removed from Chef core in 14.0 (April 2018). " \
+          "A migration cookbook will be available in the future, see the deprecation documentation for more information.")
+      end
+
       # where the checked out/cloned code goes
       def destination
         @destination ||= shared_path + "/#{@repository_cache}"

data/lib/chef/resource/dnf_package.rb

@@ -29,8 +29,15 @@ class Chef
 
       allowed_actions :install, :upgrade, :remove, :purge, :reconfig, :lock, :unlock, :flush_cache
 
-      provides :package, platform_family: %w{rhel fedora amazon} do
-        which("dnf") && shell_out("rpm -q dnf").stdout =~ /^dnf-[1-9]/
+      # all rhel variants >= 8 will use DNF
+      provides :package, platform_family: "rhel", platform_version: ">= 8"
+
+      # fedora >= 22 uses DNF
+      provides :package, platform: "fedora", platform_version: ">= 22"
+
+      # amazon will eventually use DNF
+      provides :package, platform: "amazon" do
+        which("dnf")
       end
 
       provides :dnf_package

data/lib/chef/resource/windows_task.rb

@@ -51,7 +51,8 @@ class Chef
                                        :once,
                                        :on_logon,
                                        :onstart,
-                                       :on_idle], default: :hourly
+                                       :on_idle,
+                                       :none], default: :hourly
       property :start_day, String
       property :start_time, String
       property :day, [String, Integer]
@@ -81,7 +82,7 @@ class Chef
           execution_time_limit("PT72H")
         end
 
-        validate_start_time(start_time) if frequency == :once
+        validate_start_time(start_time, frequency)
         validate_start_day(start_day, frequency) if start_day
         validate_user_and_password(user, password)
         validate_interactive_setting(interactive_enabled, password)
@@ -94,7 +95,7 @@ class Chef
       private
 
       def validate_random_delay(random_delay, frequency)
-        if [:once, :on_logon, :onstart, :on_idle].include? frequency
+        if [:once, :on_logon, :onstart, :on_idle, :none].include? frequency
           raise ArgumentError, "`random_delay` property is supported only for frequency :minute, :hourly, :daily, :weekly and :monthly"
         end
 
@@ -102,13 +103,17 @@ class Chef
       end
 
       def validate_start_day(start_day, frequency)
-        if [:once, :on_logon, :onstart, :on_idle].include? frequency
+        if [:once, :on_logon, :onstart, :on_idle, :none].include? frequency
           raise ArgumentError, "`start_day` property is not supported with frequency: #{frequency}"
         end
       end
 
-      def validate_start_time(start_time)
-        raise ArgumentError, "`start_time` needs to be provided with `frequency :once`" unless start_time
+      def validate_start_time(start_time, frequency)
+        if frequency == :once
+          raise ArgumentError, "`start_time` needs to be provided with `frequency :once`" unless start_time
+        elsif frequency == :none
+          raise ArgumentError, "`start_time` property is not supported with `frequency :none`" if start_time
+        end
       end
 
       SYSTEM_USERS = ['NT AUTHORITY\SYSTEM', "SYSTEM", 'NT AUTHORITY\LOCALSERVICE', 'NT AUTHORITY\NETWORKSERVICE', 'BUILTIN\USERS', "USERS"].freeze
@@ -132,7 +137,7 @@ class Chef
       end
 
       def validate_create_frequency_modifier(frequency, frequency_modifier)
-        # Currently is handled in create action 'frequency_modifier_allowed' line. Does not allow for frequency_modifier for once,onstart,onlogon,onidle
+        # Currently is handled in create action 'frequency_modifier_allowed' line. Does not allow for frequency_modifier for once,onstart,onlogon,onidle,none
         # Note that 'OnEvent' is not a supported frequency.
         unless frequency.nil? || frequency_modifier.nil?
           case frequency

data/lib/chef/resource/zypper_package.rb

@@ -25,6 +25,7 @@ class Chef
       provides :package, platform_family: "suse"
 
       property :gpg_check, [ TrueClass, FalseClass ], default: lazy { Chef::Config[:zypper_check_gpg] }
+      property :allow_downgrade, [ true, false ], default: false
     end
   end
 end