chef 12.18.31-universal-mingw32 → 12.19.33-universal-mingw32

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

@@ -1,7 +1,7 @@
 #
 # Author:: Jason J. W. Williams (<williamsjj@digitar.com>)
 # Author:: Stephen Nelson-Smith (<sns@chef.io>)
-# Copyright:: Copyright 2011-2016, Chef Software Inc.
+# Copyright:: Copyright 2011-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -36,45 +36,40 @@ class Chef
           super
 
           requirements.assert(:all_actions) do |a|
-            a.assertion { ! @candidate_version.nil? }
-            a.failure_message Chef::Exceptions::Package, "Package #{@new_resource.package_name} not found"
-            a.whyrun "Assuming package #{@new_resource.package_name} would have been made available."
+            a.assertion { !@candidate_version.nil? }
+            a.failure_message Chef::Exceptions::Package, "Package #{new_resource.package_name} not found"
+            a.whyrun "Assuming package #{new_resource.package_name} would have been made available."
           end
         end
 
         def get_current_version
-          shell_out_with_timeout("pkg info #{@new_resource.package_name}").stdout.each_line do |line|
+          shell_out_compact_timeout("pkg", "info", new_resource.package_name).stdout.each_line do |line|
             return $1.split[0] if line =~ /^\s+Version: (.*)/
           end
-          return nil
+          nil
         end
 
         def get_candidate_version
-          shell_out_with_timeout!("pkg info -r #{new_resource.package_name}").stdout.each_line do |line|
+          shell_out_compact_timeout!("pkg", "info", "-r", new_resource.package_name).stdout.each_line do |line|
             return $1.split[0] if line =~ /Version: (.*)/
           end
-          return nil
+          nil
         end
 
         def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.package_name)
-          Chef::Log.debug("Checking package status for #{@new_resource.name}")
-          @current_resource.version(get_current_version)
+          @current_resource = Chef::Resource::IpsPackage.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
+          Chef::Log.debug("Checking package status for #{new_resource.name}")
+          current_resource.version(get_current_version)
           @candidate_version = get_candidate_version
-          @current_resource
+          current_resource
         end
 
         def install_package(name, version)
-          package_name = "#{name}@#{version}"
-          normal_command = "pkg#{expand_options(@new_resource.options)} install -q #{package_name}"
-          command =
-            if @new_resource.respond_to?(:accept_license) && @new_resource.accept_license
-              normal_command.gsub("-q", "-q --accept")
-            else
-              normal_command
-            end
-          shell_out_with_timeout(command)
+          command = [ "pkg", options, "install", "-q" ]
+          command << "--accept" if new_resource.accept_license
+          command << "#{name}@#{version}"
+          shell_out_compact_timeout!(command)
         end
 
         def upgrade_package(name, version)
@@ -83,7 +78,7 @@ class Chef
 
         def remove_package(name, version)
           package_name = "#{name}@#{version}"
-          shell_out_with_timeout!( "pkg#{expand_options(@new_resource.options)} uninstall -q #{package_name}" )
+          shell_out_compact_timeout!( "pkg", options, "uninstall", "-q", package_name )
         end
       end
     end

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

@@ -7,25 +7,25 @@ class Chef
         provides :macports_package
 
         def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.package_name)
+          @current_resource = Chef::Resource::Package.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
 
-          @current_resource.version(current_installed_version)
-          Chef::Log.debug("#{@new_resource} current version is #{@current_resource.version}") if @current_resource.version
+          current_resource.version(current_installed_version)
+          Chef::Log.debug("#{new_resource} current version is #{current_resource.version}") if current_resource.version
 
           @candidate_version = macports_candidate_version
 
-          if !@new_resource.version && !@candidate_version
-            raise Chef::Exceptions::Package, "Could not get a candidate version for this package -- #{@new_resource.name} does not seem to be a valid package!"
+          if !new_resource.version && !@candidate_version
+            raise Chef::Exceptions::Package, "Could not get a candidate version for this package -- #{new_resource.name} does not seem to be a valid package!"
           end
 
-          Chef::Log.debug("#{@new_resource} candidate version is #{@candidate_version}") if @candidate_version
+          Chef::Log.debug("#{new_resource} candidate version is #{@candidate_version}") if @candidate_version
 
-          @current_resource
+          current_resource
         end
 
         def current_installed_version
-          command = "port installed #{@new_resource.package_name}"
+          command = [ "port", "installed", new_resource.package_name ]
           output = get_response_from_command(command)
 
           response = nil
@@ -37,7 +37,7 @@ class Chef
         end
 
         def macports_candidate_version
-          command = "port info --version #{@new_resource.package_name}"
+          command = [ "port", "info", "--version", new_resource.package_name ]
           output = get_response_from_command(command)
 
           match = output.match(/^version: (.+)$/)
@@ -46,37 +46,37 @@ class Chef
         end
 
         def install_package(name, version)
-          unless @current_resource.version == version
-            command = "port#{expand_options(@new_resource.options)} install #{name}"
-            command << " @#{version}" if version && !version.empty?
-            shell_out_with_timeout!(command)
+          unless current_resource.version == version
+            command = [ "port", options, "install", name ]
+            command << "@#{version}" if version && !version.empty?
+            shell_out_compact_timeout!(command)
           end
         end
 
         def purge_package(name, version)
-          command = "port#{expand_options(@new_resource.options)} uninstall #{name}"
-          command << " @#{version}" if version && !version.empty?
-          shell_out_with_timeout!(command)
+          command = [ "port", options, "uninstall", name ]
+          command << "@#{version}" if version && !version.empty?
+          shell_out_compact_timeout!(command)
         end
 
         def remove_package(name, version)
-          command = "port#{expand_options(@new_resource.options)} deactivate #{name}"
-          command << " @#{version}" if version && !version.empty?
+          command = [ "port", options, "deactivate", name ]
+          command << "@#{version}" if version && !version.empty?
 
-          shell_out_with_timeout!(command)
+          shell_out_compact_timeout!(command)
         end
 
         def upgrade_package(name, version)
           # Saving this to a variable -- weird rSpec behavior
           # happens otherwise...
-          current_version = @current_resource.version
+          current_version = current_resource.version
 
           if current_version.nil? || current_version.empty?
             # Macports doesn't like when you upgrade a package
             # that hasn't been installed.
             install_package(name, version)
           elsif current_version != version
-            shell_out_with_timeout!( "port#{expand_options(@new_resource.options)} upgrade #{name} @#{version}" )
+            shell_out_compact_timeout!( "port", options, "upgrade", name, "@#{version}" )
           end
         end
 
@@ -84,7 +84,7 @@ class Chef
 
         def get_response_from_command(command)
           output = nil
-          status = shell_out_with_timeout(command)
+          status = shell_out_compact_timeout(command)
           begin
             output = status.stdout
           rescue Exception

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

@@ -43,17 +43,17 @@ class Chef
           @current_resource = Chef::Resource::MsuPackage.new(new_resource.name)
 
           # download file if source is a url
-          msu_file = uri_scheme?(new_resource.source) ? download_source_file : @new_resource.source
+          msu_file = uri_scheme?(new_resource.source) ? download_source_file : new_resource.source
 
           # temp directory where the contents of msu file get extracted
           @temp_directory = Dir.mktmpdir("chef")
           extract_msu_contents(msu_file, @temp_directory)
           @cab_files = read_cab_files_from_xml(@temp_directory)
 
-          unless @cab_files.empty?
-            current_resource.version(get_current_versions)
-          else
+          if @cab_files.empty?
             raise Chef::Exceptions::Package, "Corrupt MSU package: MSU package XML does not contain any cab file"
+          else
+            current_resource.version(get_current_versions)
           end
           current_resource
         end
@@ -77,7 +77,7 @@ class Chef
         end
 
         def get_cab_package(cab_file)
-          cab_resource = @new_resource
+          cab_resource = new_resource
           cab_resource.source = cab_file
           cab_pkg = Chef::Provider::Package::Cab.new(cab_resource, nil)
         end
@@ -105,9 +105,9 @@ class Chef
         end
 
         def install_package(name, version)
-          #use cab_package resource to install the extracted cab packages
+          # use cab_package resource to install the extracted cab packages
           @cab_files.each do |cab_file|
-            declare_resource(:cab_package, @new_resource.name) do
+            declare_resource(:cab_package, new_resource.name) do
               source cab_file
               action :install
             end
@@ -115,9 +115,9 @@ class Chef
         end
 
         def remove_package(name, version)
-          #use cab_package provider to remove the extracted cab packages
+          # use cab_package provider to remove the extracted cab packages
           @cab_files.each do |cab_file|
-            declare_resource(:cab_package, @new_resource.name) do
+            declare_resource(:cab_package, new_resource.name) do
               source cab_file
               action :remove
             end
@@ -141,7 +141,7 @@ class Chef
             raise Chef::Exceptions::Package, "Corrupt MSU package: MSU package doesn't contain any xml file"
           else
             # msu package contains only single xml file. So using xml_files.first is sufficient
-            doc = ::File.open("#{xml_files.first}") { |f| REXML::Document.new f }
+            doc = ::File.open(xml_files.first.to_s) { |f| REXML::Document.new f }
             locations = doc.elements.each("unattend/servicing/package/source") { |element| puts element.attributes["location"] }
             locations.each do |loc|
               cab_files << msu_dir + "/" + loc.attribute("location").value.split("\\")[1]
@@ -154,7 +154,7 @@ class Chef
 
         def cleanup_after_converge
           # delete the temp directory where the contents of msu file are extracted
-          FileUtils.rm_rf(@temp_directory) if Dir.exists?(@temp_directory)
+          FileUtils.rm_rf(@temp_directory) if Dir.exist?(@temp_directory)
         end
       end
     end

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

@@ -42,9 +42,9 @@ class Chef
         end
 
         def load_current_resource
-          @current_resource.package_name(new_resource.package_name)
-          @current_resource.version(installed_version)
-          @current_resource
+          current_resource.package_name(new_resource.package_name)
+          current_resource.version(installed_version)
+          current_resource
         end
 
         def define_resource_requirements
@@ -68,11 +68,11 @@ class Chef
         end
 
         def install_package(name, version)
-          unless @current_resource.version
+          unless current_resource.version
             if parts = name.match(/^(.+?)--(.+)/) # use double-dash for stems with flavors, see man page for pkg_add
               name = parts[1]
             end
-            shell_out_with_timeout!("pkg_add -r #{name}#{version_string(version)}", :env => { "PKG_PATH" => pkg_path }).status
+            shell_out_compact_timeout!("pkg_add", "-r", package_string(name, version), env: { "PKG_PATH" => pkg_path }).status
             Chef::Log.debug("#{new_resource.package_name} installed")
           end
         end
@@ -81,18 +81,18 @@ class Chef
           if parts = name.match(/^(.+?)--(.+)/)
             name = parts[1]
           end
-          shell_out_with_timeout!("pkg_delete #{name}#{version_string(version)}", :env => nil).status
+          shell_out_compact_timeout!("pkg_delete", package_string(name, version), env: nil).status
         end
 
         private
 
         def installed_version
-          if parts = new_resource.package_name.match(/^(.+?)--(.+)/)
-            name = parts[1]
-          else
-            name = new_resource.package_name
-          end
-          pkg_info = shell_out_with_timeout!("pkg_info -e \"#{name}->0\"", :env => nil, :returns => [0, 1])
+          name = if parts = new_resource.package_name.match(/^(.+?)--(.+)/)
+                   parts[1]
+                 else
+                   new_resource.package_name
+                 end
+          pkg_info = shell_out_compact_timeout!("pkg_info", "-e", "#{name}->0", env: nil, returns: [0, 1])
           result = pkg_info.stdout[/^inst:#{Regexp.escape(name)}-(.+?)\s/, 1]
           Chef::Log.debug("installed_version of '#{new_resource.package_name}' is '#{result}'")
           result
@@ -101,12 +101,12 @@ class Chef
         def candidate_version
           @candidate_version ||= begin
             results = []
-            shell_out_with_timeout!("pkg_info -I \"#{new_resource.package_name}#{version_string(new_resource.version)}\"", :env => nil, :returns => [0, 1]).stdout.each_line do |line|
-              if parts = new_resource.package_name.match(/^(.+?)--(.+)/)
-                results << line[/^#{Regexp.escape(parts[1])}-(.+?)\s/, 1]
-              else
-                results << line[/^#{Regexp.escape(new_resource.package_name)}-(.+?)\s/, 1]
-              end
+            shell_out_compact_timeout!("pkg_info", "-I", package_string(new_resource.package_name, new_resource.version), env: nil, returns: [0, 1]).stdout.each_line do |line|
+              results << if parts = new_resource.package_name.match(/^(.+?)--(.+)/)
+                           line[/^#{Regexp.escape(parts[1])}-(.+?)\s/, 1]
+                         else
+                           line[/^#{Regexp.escape(new_resource.package_name)}-(.+?)\s/, 1]
+                         end
             end
             results = results.reject(&:nil?)
             Chef::Log.debug("Candidate versions of '#{new_resource.package_name}' are '#{results}'")
@@ -121,13 +121,16 @@ class Chef
           end
         end
 
-        def version_string(version)
-          ver  = ""
-          ver += "-#{version}" if version
+        def package_string(name, version)
+          if version
+            "#{name}-#{version}"
+          else
+            name
+          end
         end
 
         def pkg_path
-          ENV["PKG_PATH"] || "http://ftp.OpenBSD.org/pub/#{node["kernel"]["name"]}/#{node["kernel"]["release"]}/packages/#{node["kernel"]["machine"]}/"
+          ENV["PKG_PATH"] || "http://ftp.OpenBSD.org/pub/#{node['kernel']['name']}/#{node['kernel']['release']}/packages/#{node['kernel']['machine']}/"
         end
 
       end

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

@@ -29,16 +29,16 @@ class Chef
         provides :pacman_package, os: "linux"
 
         def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.package_name)
+          @current_resource = Chef::Resource::Package.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
 
-          Chef::Log.debug("#{@new_resource} checking pacman for #{@new_resource.package_name}")
-          status = shell_out_with_timeout("pacman -Qi #{@new_resource.package_name}")
+          Chef::Log.debug("#{new_resource} checking pacman for #{new_resource.package_name}")
+          status = shell_out_compact_timeout("pacman", "-Qi", new_resource.package_name)
           status.stdout.each_line do |line|
             case line
             when /^Version(\s?)*: (.+)$/
-              Chef::Log.debug("#{@new_resource} current version is #{$2}")
-              @current_resource.version($2)
+              Chef::Log.debug("#{new_resource} current version is #{$2}")
+              current_resource.version($2)
             end
           end
 
@@ -46,7 +46,7 @@ class Chef
             raise Chef::Exceptions::Package, "pacman failed - #{status.inspect}!"
           end
 
-          @current_resource
+          current_resource
         end
 
         def candidate_version
@@ -54,20 +54,20 @@ class Chef
 
           repos = %w{extra core community}
 
-          if ::File.exists?("/etc/pacman.conf")
+          if ::File.exist?("/etc/pacman.conf")
             pacman = ::File.read("/etc/pacman.conf")
             repos = pacman.scan(/\[(.+)\]/).flatten
           end
 
           package_repos = repos.map { |r| Regexp.escape(r) }.join("|")
 
-          status = shell_out_with_timeout("pacman -Sl")
+          status = shell_out_compact_timeout("pacman", "-Sl")
           status.stdout.each_line do |line|
             case line
-              when /^(#{package_repos}) #{Regexp.escape(@new_resource.package_name)} (.+)$/
-                # $2 contains a string like "4.4.0-1" or "3.10-4 [installed]"
-                # simply split by space and use first token
-                @candidate_version = $2.split(" ").first
+            when /^(#{package_repos}) #{Regexp.escape(new_resource.package_name)} (.+)$/
+              # $2 contains a string like "4.4.0-1" or "3.10-4 [installed]"
+              # simply split by space and use first token
+              @candidate_version = $2.split(" ").first
             end
           end
 
@@ -76,14 +76,14 @@ class Chef
           end
 
           unless @candidate_version
-            raise Chef::Exceptions::Package, "pacman does not have a version of package #{@new_resource.package_name}"
+            raise Chef::Exceptions::Package, "pacman does not have a version of package #{new_resource.package_name}"
           end
 
           @candidate_version
         end
 
         def install_package(name, version)
-          shell_out_with_timeout!( "pacman --sync --noconfirm --noprogressbar#{expand_options(@new_resource.options)} #{name}" )
+          shell_out_compact_timeout!( "pacman", "--sync", "--noconfirm", "--noprogressbar", options, name)
         end
 
         def upgrade_package(name, version)
@@ -91,7 +91,7 @@ class Chef
         end
 
         def remove_package(name, version)
-          shell_out_with_timeout!( "pacman --remove --noconfirm --noprogressbar#{expand_options(@new_resource.options)} #{name}" )
+          shell_out_compact_timeout!( "pacman", "--remove", "--noconfirm", "--noprogressbar", options, name )
         end
 
         def purge_package(name, version)

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

@@ -28,38 +28,37 @@ class Chef
         provides :paludis_package, os: "linux"
 
         def load_current_resource
-          @current_resource = Chef::Resource::Package.new(@new_resource.package_name)
-          @current_resource.package_name(@new_resource.package_name)
+          @current_resource = Chef::Resource::Package.new(new_resource.package_name)
+          current_resource.package_name(new_resource.package_name)
 
-          Chef::Log.debug("Checking package status for #{@new_resource.package_name}")
+          Chef::Log.debug("Checking package status for #{new_resource.package_name}")
           installed = false
           re = Regexp.new("(.*)[[:blank:]](.*)[[:blank:]](.*)$")
 
-          shell_out!("cave -L warning print-ids -M none -m \"#{@new_resource.package_name}\" -f \"%c/%p %v %r\n\"").stdout.each_line do |line|
+          shell_out_compact!("cave", "-L", "warning", "print-ids", "-M", "none", "-m", new_resource.package_name, "-f", "%c/%p %v %r\n").stdout.each_line do |line|
             res = re.match(line)
-            unless res.nil?
-              case res[3]
-              when "accounts", "installed-accounts"
-                next
-              when "installed"
-                installed = true
-                @current_resource.version(res[2])
-              else
-                @candidate_version = res[2]
-              end
+            next if res.nil?
+            case res[3]
+            when "accounts", "installed-accounts"
+              next
+            when "installed"
+              installed = true
+              current_resource.version(res[2])
+            else
+              @candidate_version = res[2]
             end
           end
 
-          @current_resource
+          current_resource
         end
 
         def install_package(name, version)
-          if version
-            pkg = "=#{name}-#{version}"
-          else
-            pkg = "#{@new_resource.package_name}"
-          end
-          shell_out!("cave -L warning resolve -x#{expand_options(@new_resource.options)} \"#{pkg}\"", :timeout => @new_resource.timeout)
+          pkg = if version
+                  "=#{name}-#{version}"
+                else
+                  new_resource.package_name.to_s
+                end
+          shell_out_compact_timeout!("cave", "-L", "warning", "resolve", "-x", options, pkg)
         end
 
         def upgrade_package(name, version)
@@ -67,13 +66,13 @@ class Chef
         end
 
         def remove_package(name, version)
-          if version
-            pkg = "=#{@new_resource.package_name}-#{version}"
-          else
-            pkg = "#{@new_resource.package_name}"
-          end
+          pkg = if version
+                  "=#{new_resource.package_name}-#{version}"
+                else
+                  new_resource.package_name.to_s
+                end
 
-          shell_out!("cave -L warning uninstall -x#{expand_options(@new_resource.options)} \"#{pkg}\"")
+          shell_out_compact!("cave", "-L", "warning", "uninstall", "-x", options, pkg)
         end
 
         def purge_package(name, version)