chef 12.5.1 → 12.6.0

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

@@ -17,124 +17,207 @@
 #
 
 require 'chef/provider/package'
-require 'chef/mixin/command'
 require 'chef/resource/package'
-require 'chef/mixin/get_source_from_package'
 
 class Chef
   class Provider
     class Package
       class Dpkg < Chef::Provider::Package
+        DPKG_REMOVED = /^Status: deinstall ok config-files/
         DPKG_INSTALLED = /^Status: install ok installed/
         DPKG_VERSION = /^Version: (.+)$/
 
         provides :dpkg_package, os: "linux"
 
-        include Chef::Mixin::GetSourceFromPackage
+        use_multipackage_api
+        use_package_name_for_source
 
         def define_resource_requirements
           super
-          requirements.assert(:install) do |a|
-            a.assertion{ not @new_resource.source.nil? }
-            a.failure_message Chef::Exceptions::Package, "Source for package #{@new_resource.name} required for action install"
+
+          requirements.assert(:install, :upgrade) do |a|
+            a.assertion { !resolved_source_array.compact.empty? }
+            a.failure_message Chef::Exceptions::Package, "#{new_resource} the source property is required for action :install or :upgrade"
           end
 
-          # TODO this was originally written for any action in which .source is provided
-          # but would it make more sense to only look at source if the action is :install?
-          requirements.assert(:all_actions) do |a|
-            a.assertion { @source_exists }
-            a.failure_message Chef::Exceptions::Package, "Package #{@new_resource.name} not found: #{@new_resource.source}"
-            a.whyrun "Assuming it would have been previously downloaded."
+          requirements.assert(:install, :upgrade) do |a|
+            a.assertion { source_files_exist? }
+            a.failure_message Chef::Exceptions::Package, "#{new_resource} source file(s) do not exist: #{missing_sources}"
+            a.whyrun "Assuming they would have been previously created."
           end
         end
 
         def load_current_resource
-          @source_exists = true
-          @current_resource = Chef::Resource::Package.new(@new_resource.name)
-          @current_resource.package_name(@new_resource.package_name)
-
-          if @new_resource.source
-            @source_exists = ::File.exists?(@new_resource.source)
-            if @source_exists
-              # Get information from the package if supplied
-              Chef::Log.debug("#{@new_resource} checking dpkg status")
-              status = shell_out_with_timeout("dpkg-deb -W #{@new_resource.source}")
-              pkginfo = status.stdout.split("\t")
-              unless pkginfo.empty?
-                @current_resource.package_name(pkginfo[0])
-                @candidate_version = pkginfo[1].strip
-              end
-            else
-              # Source provided but not valid means we can't safely do further processing
-              return
-            end
+          @current_resource = Chef::Resource::Package.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
+
+          if source_files_exist?
+            @candidate_version = get_candidate_version
+            current_resource.package_name(get_package_name)
+            # if the source file exists then our package_name is right
+            current_resource.version(get_current_version_from(current_package_name_array))
+          elsif !installing?
+            # we can't do this if we're installing with no source, because our package_name
+            # is probably not right.
+            #
+            # if we're removing or purging we don't use source, and our package_name must
+            # be right so we can do this.
+            #
+            # we don't error here on the dpkg command since we'll handle the exception or
+            # the why-run message in define_resource_requirements.
+            current_resource.version(get_current_version_from(current_package_name_array))
           end
 
-          # Check to see if it is installed
-          package_installed = nil
-          Chef::Log.debug("#{@new_resource} checking install state")
-          status = shell_out_with_timeout("dpkg -s #{@current_resource.package_name}")
+          current_resource
+        end
+
+        def install_package(name, version)
+          sources = name.map { |n| name_sources[n] }
+          Chef::Log.info("#{new_resource} installing package(s): #{name.join(' ')}")
+          run_noninteractive("dpkg -i", new_resource.options, *sources)
+        end
+
+        def remove_package(name, version)
+          Chef::Log.info("#{new_resource} removing package(s): #{name.join(' ')}")
+          run_noninteractive("dpkg -r", new_resource.options, *name)
+        end
+
+        def purge_package(name, version)
+          Chef::Log.info("#{new_resource} purging packages(s): #{name.join(' ')}")
+          run_noninteractive("dpkg -P", new_resource.options, *name)
+        end
+
+        def upgrade_package(name, version)
+          install_package(name, version)
+        end
+
+        def preseed_package(preseed_file)
+          Chef::Log.info("#{new_resource} pre-seeding package installation instructions")
+          run_noninteractive("debconf-set-selections", *preseed_file)
+        end
+
+        def reconfig_package(name, version)
+          Chef::Log.info("#{new_resource} reconfiguring")
+          run_noninteractive("dpkg-reconfigure", *name)
+        end
+
+        # Override the superclass check.  Multiple sources are required here.
+        def check_resource_semantics!
+        end
+
+        private
+
+        def read_current_version_of_package(package_name)
+          Chef::Log.debug("#{new_resource} checking install state of #{package_name}")
+          status = shell_out_with_timeout!("dpkg -s #{package_name}", returns: [0, 1])
+          package_installed = false
           status.stdout.each_line do |line|
             case line
+            when DPKG_REMOVED
+              # if we are 'purging' then we consider 'removed' to be 'installed'
+              package_installed = true if action == :purge
             when DPKG_INSTALLED
               package_installed = true
             when DPKG_VERSION
               if package_installed
-                Chef::Log.debug("#{@new_resource} current version is #{$1}")
-                @current_resource.version($1)
+                Chef::Log.debug("#{new_resource} current version is #{$1}")
+                return $1
               end
             end
           end
+          return nil
+        end
 
-          unless status.exitstatus == 0 || status.exitstatus == 1
-            raise Chef::Exceptions::Package, "dpkg failed - #{status.inspect}!"
+        def get_current_version_from(array)
+          array.map do |name|
+            read_current_version_of_package(name)
           end
+        end
 
-          @current_resource
+        # Runs command via shell_out_with_timeout with magic environment to disable
+        # interactive prompts.
+        def run_noninteractive(*command)
+          shell_out_with_timeout!(a_to_s(*command), :env => { "DEBIAN_FRONTEND" => "noninteractive" })
         end
 
-        def install_package(name, version)
-          Chef::Log.info("#{@new_resource} installing #{@new_resource.source}")
-          run_noninteractive(
-            "dpkg -i#{expand_options(@new_resource.options)} #{@new_resource.source}"
-          )
+        # Returns true if all sources exist.  Returns false if any do not, or if no
+        # sources were specified.
+        #
+        # @return [Boolean] True if all sources exist
+        def source_files_exist?
+          resolved_source_array.all? {|s| s && ::File.exist?(s) }
         end
 
-        def remove_package(name, version)
-          Chef::Log.info("#{@new_resource} removing #{@new_resource.package_name}")
-          run_noninteractive(
-            "dpkg -r#{expand_options(@new_resource.options)} #{@new_resource.package_name}"
-          )
+        # Helper to return all the nanes of the missing sources for error messages.
+        #
+        # @return [Array<String>] Array of missing sources
+        def missing_sources
+          resolved_source_array.select {|s| s.nil? || !::File.exist?(s) }
         end
 
-        def purge_package(name, version)
-          Chef::Log.info("#{@new_resource} purging #{@new_resource.package_name}")
-          run_noninteractive(
-            "dpkg -P#{expand_options(@new_resource.options)} #{@new_resource.package_name}"
-          )
+        def current_package_name_array
+          [ current_resource.package_name ].flatten
         end
 
-        def upgrade_package(name, version)
-          install_package(name, version)
+        # Helper to construct Hash of names-to-sources.
+        #
+        # @return [Hash] Mapping of package names to sources
+        def name_sources
+          @name_sources =
+            begin
+              Hash[*package_name_array.zip(resolved_source_array).flatten]
+            end
         end
 
-        def preseed_package(preseed_file)
-          Chef::Log.info("#{@new_resource} pre-seeding package installation instructions")
-          run_noninteractive("debconf-set-selections #{preseed_file}")
+        # Helper to construct Hash of names-to-package-information.
+        #
+        # @return [Hash] Mapping of package names to package information
+        def name_pkginfo
+          @name_pkginfo ||=
+            begin
+              pkginfos = resolved_source_array.map do |src|
+                Chef::Log.debug("#{new_resource} checking #{src} dpkg status")
+                status = shell_out_with_timeout!("dpkg-deb -W #{src}")
+                status.stdout
+              end
+              Hash[*package_name_array.zip(pkginfos).flatten]
+            end
         end
 
-        def reconfig_package(name, version)
-          Chef::Log.info("#{@new_resource} reconfiguring")
-          run_noninteractive("dpkg-reconfigure #{name}")
+        def name_candidate_version
+          @name_candidate_version ||=
+            begin
+              Hash[name_pkginfo.map {|k, v| [k, v ? v.split("\t")[1].strip : nil] }]
+            end
         end
 
-        # Runs command via shell_out_with_timeout with magic environment to disable
-        # interactive prompts. Command is run with default localization rather
-        # than forcing locale to "C", so command output may not be stable.
+        def name_package_name
+          @name_package_name ||=
+            begin
+              Hash[name_pkginfo.map {|k, v| [k, v ? v.split("\t")[0] : nil] }]
+            end
+        end
+
+        # Return candidate version array from pkg-deb -W against the source file(s).
+        #
+        # @return [Array] Array of candidate versions read from the source files
+        def get_candidate_version
+          package_name_array.map { |name| name_candidate_version[name] }
+        end
+
+        # Return package names from the candidate source file(s).
+        #
+        # @return [Array] Array of actual package names read from the source files
+        def get_package_name
+          package_name_array.map { |name| name_package_name[name] }
+        end
+
+        # Since upgrade just calls install, this is a helper to determine
+        # if our action means that we'll be calling install_package.
         #
-        # FIXME: This should be "LC_ALL" => "en_US.UTF-8" in order to stabilize the output and get UTF-8
-        def run_noninteractive(command)
-          shell_out_with_timeout!(command, :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil })
+        # @return [Boolean] true if we're doing :install or :upgrade
+        def installing?
+          [:install, :upgrade].include?(action)
         end
 
       end

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

@@ -72,18 +72,16 @@ class Chef
             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}", :env => {"PKG_PATH" => pkg_path}).status
+            shell_out_with_timeout!("pkg_add -r #{name}#{version_string(version)}", :env => {"PKG_PATH" => pkg_path}).status
             Chef::Log.debug("#{new_resource.package_name} installed")
           end
         end
 
         def remove_package(name, version)
-          version_string  = ''
-          version_string += "-#{version}" if version
           if parts = name.match(/^(.+?)--(.+)/)
             name = parts[1]
           end
-          shell_out_with_timeout!("pkg_delete #{name}#{version_string}", :env => nil).status
+          shell_out_with_timeout!("pkg_delete #{name}#{version_string(version)}", :env => nil).status
         end
 
         private
@@ -103,7 +101,7 @@ class Chef
         def candidate_version
           @candidate_version ||= begin
             results = []
-            shell_out_with_timeout!("pkg_info -I \"#{new_resource.package_name}#{version_string}\"", :env => nil, :returns => [0,1]).stdout.each_line do |line|
+            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
@@ -111,7 +109,7 @@ class Chef
               end
             end
             results = results.reject(&:nil?)
-            Chef::Log.debug("candidate versions of '#{new_resource.package_name}' are '#{results}'")
+            Chef::Log.debug("Candidate versions of '#{new_resource.package_name}' are '#{results}'")
             case results.length
             when 0
               []
@@ -123,9 +121,9 @@ class Chef
           end
         end
 
-        def version_string
+        def version_string(version)
           ver  = ''
-          ver += "-#{new_resource.version}" if new_resource.version
+          ver += "-#{version}" if version
         end
 
         def pkg_path

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

@@ -125,6 +125,8 @@ class Chef
           end
         end
 
+        alias_method :upgrade_package, :install_package
+
         def remove_package(name, version)
           if @new_resource.options.nil?
             shell_out_with_timeout!( "pkgrm -n #{name}" )

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

@@ -32,11 +32,7 @@ class Chef
         provides :package, os: "windows"
         provides :windows_package, os: "windows"
 
-        # Depending on the installer, we may need to examine installer_type or
-        # source attributes, or search for text strings in the installer file
-        # binary to determine the installer type for the user. Since the file
-        # must be on disk to do so, we have to make this choice in the provider.
-        require 'chef/provider/package/windows/msi.rb'
+        require 'chef/provider/package/windows/registry_uninstall_entry.rb'
 
         # load_current_resource is run in Chef::Provider#run_action when not in whyrun_mode?
         def load_current_resource
@@ -56,24 +52,64 @@ class Chef
           @package_provider ||= begin
             case installer_type
             when :msi
-              Chef::Provider::Package::Windows::MSI.new(resource_for_provider)
+              Chef::Log.debug("#{@new_resource} is MSI")
+              require 'chef/provider/package/windows/msi'
+              Chef::Provider::Package::Windows::MSI.new(resource_for_provider, uninstall_registry_entries)
             else
-              raise "Unable to find a Chef::Provider::Package::Windows provider for installer_type '#{installer_type}'"
+              Chef::Log.debug("#{@new_resource} is EXE with type '#{installer_type}'")
+              require 'chef/provider/package/windows/exe'
+              Chef::Provider::Package::Windows::Exe.new(resource_for_provider, installer_type, uninstall_registry_entries)
             end
           end
         end
 
         def installer_type
+          # Depending on the installer, we may need to examine installer_type or
+          # source attributes, or search for text strings in the installer file
+          # binary to determine the installer type for the user. Since the file
+          # must be on disk to do so, we have to make this choice in the provider.
           @installer_type ||= begin
             if @new_resource.installer_type
               @new_resource.installer_type
-            else
-              file_extension = ::File.basename(@new_resource.source).split(".").last.downcase
+            elsif source_location.nil?
+                inferred_registry_type
+            else    
+              basename = ::File.basename(source_location)
+              file_extension = basename.split(".").last.downcase
 
               if file_extension == "msi"
                 :msi
               else
-                raise ArgumentError, "Installer type for Windows Package '#{@new_resource.name}' not specified and cannot be determined from file extension '#{file_extension}'"
+                # search the binary file for installer type
+                ::Kernel.open(::File.expand_path(source_location), 'rb') do |io|
+                  filesize = io.size
+                  bufsize = 4096 # read 4K buffers
+                  overlap = 16 # bytes to overlap between buffer reads
+
+                  until io.eof
+                    contents = io.read(bufsize)
+
+                    case contents
+                    when /inno/i # Inno Setup
+                      return :inno
+                    when /wise/i # Wise InstallMaster
+                      return :wise
+                    when /nullsoft/i # Nullsoft Scriptable Install System
+                      return :nsis
+                    end
+
+                    if (io.tell() < filesize)
+                      io.seek(io.tell() - overlap)
+                    end
+                  end
+                 end
+
+                # if file is named 'setup.exe' assume installshield
+                if basename == 'setup.exe'
+                  :installshield
+                else
+                  fail Chef::Exceptions::CannotDetermineWindowsInstallerType, "Installer type for Windows Package '#{@new_resource.name}' not specified and cannot be determined from file extension '#{file_extension}'"
+                end
               end
             end
           end
@@ -93,11 +129,11 @@ class Chef
         # Chef::Provider::Package action_install + action_remove call install_package + remove_package
         # Pass those calls to the correct sub-provider
         def install_package(name, version)
-          package_provider.install_package(name, version)
+          package_provider.install_package
         end
 
         def remove_package(name, version)
-          package_provider.remove_package(name, version)
+          package_provider.remove_package
         end
 
         # @return [Array] new_version(s) as an array
@@ -106,15 +142,59 @@ class Chef
           [new_resource.version]
         end
 
+        # @return [String] candidate_version
+        def candidate_version
+          @candidate_version ||= (@new_resource.version || 'latest')
+        end
+
+        # @return [Array] current_version(s) as an array
+        # this package provider does not support package arrays
+        # However, There may be multiple versions for a single 
+        # package so the first element may be a nested array
+        def current_version_array
+          [ current_resource.version ]
+        end
+
+        # @param current_version<String> one or more versions currently installed
+        # @param new_version<String> version of the new resource
+        #
+        # @return [Boolean] true if new_version is equal to or included in current_version
+        def target_version_already_installed?(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)
+          else
+            new_version == current_version
+          end
+        end
+
+        def have_any_matching_version?
+          target_version_already_installed?(current_resource.version, new_resource.version)
+        end
+
         private
 
+        def uninstall_registry_entries
+          @uninstall_registry_entries ||= Chef::Provider::Package::Windows::RegistryUninstallEntry.find_entries(new_resource.name)
+        end
+
+        def inferred_registry_type
+          uninstall_registry_entries.each do |entry|
+            return :inno if entry.key.end_with?("_is1")
+            return :msi if entry.uninstall_string.downcase.start_with?("msiexec.exe ")
+            return :nsis if entry.uninstall_string.downcase.end_with?("uninst.exe\"")
+          end
+          nil
+        end
+
         def downloadable_file_missing?
           uri_scheme?(new_resource.source) && !::File.exists?(source_location)
         end
 
         def resource_for_provider
           @resource_for_provider = Chef::Resource::WindowsPackage.new(new_resource.name).tap do |r|
-            r.source(Chef::Util::PathHelper.validate_path(source_location))
+            r.source(Chef::Util::PathHelper.validate_path(source_location)) unless source_location.nil?
+            r.version(new_resource.version)
             r.timeout(new_resource.timeout)
             r.returns(new_resource.returns)
             r.options(new_resource.options)
@@ -151,7 +231,8 @@ class Chef
           if uri_scheme?(new_resource.source)
             source_resource.path
           else
-            Chef::Util::PathHelper.cleanpath(new_resource.source)
+            new_source = Chef::Util::PathHelper.cleanpath(new_resource.source)
+            ::File.exist?(new_source) ? new_source : nil
           end
         end