chef 12.5.1 → 12.6.0

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

@@ -0,0 +1,129 @@
+#
+# Author:: Seth Chisamore (<schisamo@chef.io>)
+# Author:: Matt Wrock <matt@mattwrock.com>
+# Copyright:: Copyright (c) 2011, 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/mixin/shell_out'
+
+class Chef
+  class Provider
+    class Package
+      class Windows
+        class Exe
+          include Chef::Mixin::ShellOut
+
+          def initialize(resource, installer_type, uninstall_entries)
+            @new_resource = resource
+            @installer_type = installer_type
+            @uninstall_entries = uninstall_entries
+          end
+
+          attr_reader :new_resource
+          attr_reader :installer_type
+          attr_reader :uninstall_entries
+
+          # From Chef::Provider::Package
+          def expand_options(options)
+            options ? " #{options}" : ""
+          end
+
+          # Returns a version if the package is installed or nil if it is not.
+          def installed_version
+            Chef::Log.debug("#{new_resource} checking package version")
+            current_installed_version
+          end
+
+          def package_version
+            new_resource.version || install_file_version
+          end
+
+          def install_package
+            Chef::Log.debug("#{new_resource} installing #{new_resource.installer_type} package '#{new_resource.source}'")
+            shell_out!(
+              [
+                "start",
+                "\"\"",
+                "/wait",
+                "\"#{new_resource.source}\"",
+                unattended_flags,
+                expand_options(new_resource.options),
+                "& exit %%%%ERRORLEVEL%%%%"
+              ].join(" "), timeout: new_resource.timeout, returns: new_resource.returns
+            )
+          end
+
+          def remove_package
+            uninstall_version = new_resource.version || current_installed_version
+            uninstall_entries.select { |entry| [uninstall_version].flatten.include?(entry.display_version) }
+              .map { |version| version.uninstall_string }.uniq.each do |uninstall_string|
+                Chef::Log.debug("Registry provided uninstall string for #{new_resource} is '#{uninstall_string}'")
+                shell_out!(uninstall_command(uninstall_string), { returns: new_resource.returns })
+              end
+          end
+
+          private
+
+          def uninstall_command(uninstall_string)
+            uninstall_string.delete!('"')
+            uninstall_string = [
+              %q{/d"},
+              ::File.dirname(uninstall_string),
+              %q{" },
+              ::File.basename(uninstall_string),
+              expand_options(new_resource.options),
+              " ",
+              unattended_flags
+            ].join
+            %Q{start "" /wait #{uninstall_string} & exit %%%%ERRORLEVEL%%%%}
+          end
+
+          def current_installed_version
+            @current_installed_version ||= uninstall_entries.count == 0 ? nil : begin
+              uninstall_entries.map { |entry| entry.display_version }.uniq
+            end
+          end
+
+          def install_file_version
+            @install_file_version ||= begin
+              if ::File.exist?(@new_resource.source)
+                version_info = Chef::ReservedNames::Win32::File.version_info(new_resource.source)
+                file_version = version_info.FileVersion || version_info.ProductVersion
+                file_version == '' ? nil : file_version
+              else
+                nil
+              end
+            end
+          end
+
+          # http://unattended.sourceforge.net/installers.php
+          def unattended_flags
+            case installer_type
+            when :installshield
+              '/s /sms'
+            when :nsis
+              '/S /NCRC'
+            when :inno
+              '/VERYSILENT /SUPPRESSMSGBOXES /NORESTART'
+            when :wise
+              '/s'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -29,10 +29,14 @@ class Chef
           include Chef::ReservedNames::Win32::API::Installer if (RUBY_PLATFORM =~ /mswin|mingw32|windows/) && Chef::Platform.supports_msi?
           include Chef::Mixin::ShellOut
 
-          def initialize(resource)
+          def initialize(resource, uninstall_entries)
             @new_resource = resource
+            @uninstall_entries = uninstall_entries
           end
 
+          attr_reader :new_resource
+          attr_reader :uninstall_entries
+
           # From Chef::Provider::Package
           def expand_options(options)
             options ? " #{options}" : ""
@@ -40,27 +44,47 @@ class Chef
 
           # Returns a version if the package is installed or nil if it is not.
           def installed_version
-            Chef::Log.debug("#{@new_resource} getting product code for package at #{@new_resource.source}")
-            product_code = get_product_property(@new_resource.source, "ProductCode")
-            Chef::Log.debug("#{@new_resource} checking package status and version for #{product_code}")
-            get_installed_version(product_code)
+            if ::File.exist?(new_resource.source)
+              Chef::Log.debug("#{new_resource} getting product code for package at #{new_resource.source}")
+              product_code = get_product_property(new_resource.source, "ProductCode")
+              Chef::Log.debug("#{new_resource} checking package status and version for #{product_code}")
+              get_installed_version(product_code)
+            else
+              uninstall_entries.count == 0 ? nil : begin
+                uninstall_entries.map { |entry| entry.display_version }.uniq
+              end
+            end
           end
 
           def package_version
-            Chef::Log.debug("#{@new_resource} getting product version for package at #{@new_resource.source}")
-            get_product_property(@new_resource.source, "ProductVersion")
+            return new_resource.version if new_resource.version
+            if ::File.exist?(new_resource.source)
+              Chef::Log.debug("#{new_resource} getting product version for package at #{new_resource.source}")
+              get_product_property(new_resource.source, "ProductVersion")
+            end
           end
 
-          def install_package(name, version)
+          def install_package
             # We could use MsiConfigureProduct here, but we'll start off with msiexec
-            Chef::Log.debug("#{@new_resource} installing MSI package '#{@new_resource.source}'")
-            shell_out!("msiexec /qn /i \"#{@new_resource.source}\" #{expand_options(@new_resource.options)}", {:timeout => @new_resource.timeout, :returns => @new_resource.returns})
+            Chef::Log.debug("#{new_resource} installing MSI package '#{new_resource.source}'")
+            shell_out!("msiexec /qn /i \"#{new_resource.source}\" #{expand_options(new_resource.options)}", {:timeout => new_resource.timeout, :returns => new_resource.returns})
           end
 
-          def remove_package(name, version)
+          def remove_package
             # We could use MsiConfigureProduct here, but we'll start off with msiexec
-            Chef::Log.debug("#{@new_resource} removing MSI package '#{@new_resource.source}'")
-            shell_out!("msiexec /qn /x \"#{@new_resource.source}\" #{expand_options(@new_resource.options)}", {:timeout => @new_resource.timeout, :returns => @new_resource.returns})
+            if ::File.exist?(new_resource.source)
+              Chef::Log.debug("#{new_resource} removing MSI package '#{new_resource.source}'")
+              shell_out!("msiexec /qn /x \"#{new_resource.source}\" #{expand_options(new_resource.options)}", {:timeout => new_resource.timeout, :returns => new_resource.returns})
+            else
+              uninstall_version = new_resource.version || installed_version
+              uninstall_entries.select { |entry| [uninstall_version].flatten.include?(entry.display_version) }
+                .map { |version| version.uninstall_string }.uniq.each do |uninstall_string|
+                  Chef::Log.debug("#{new_resource} removing MSI package version using '#{uninstall_string}'")
+                  uninstall_string += expand_options(new_resource.options)
+                  uninstall_string += " /Q" unless uninstall_string =~ / \/Q\b/
+                  shell_out!(uninstall_string, {:timeout => new_resource.timeout, :returns => new_resource.returns})
+              end
+            end
           end
         end
       end

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

@@ -0,0 +1,89 @@
+#
+# Author:: Seth Chisamore (<schisamo@chef.io>)
+# Author:: Matt Wrock <matt@mattwrock.com>
+# Copyright:: Copyright (c) 2011, 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'win32/registry' if (RUBY_PLATFORM =~ /mswin|mingw32|windows/)
+
+class Chef
+  class Provider
+    class Package
+      class Windows
+        class RegistryUninstallEntry
+
+          def self.find_entries(package_name)
+            Chef::Log.debug("Finding uninstall entries for #{package_name}")
+            entries = []
+            [
+              [::Win32::Registry::HKEY_LOCAL_MACHINE, (::Win32::Registry::Constants::KEY_READ | 0x0100)],
+              [::Win32::Registry::HKEY_LOCAL_MACHINE, (::Win32::Registry::Constants::KEY_READ | 0x0200)],
+              [::Win32::Registry::HKEY_CURRENT_USER]
+            ].each do |hkey|
+              desired = hkey.length > 1 ? hkey[1] : ::Win32::Registry::Constants::KEY_READ
+              begin
+                ::Win32::Registry.open(hkey[0], UNINSTALL_SUBKEY, desired) do |reg|
+                  reg.each_key do |key, _wtime|
+                    begin
+                      entry = reg.open(key, desired)
+                      display_name = read_registry_property(entry, 'DisplayName')
+                      if display_name == package_name
+                        entries.push(RegistryUninstallEntry.new(hkey, key, entry))
+                      end
+                    rescue ::Win32::Registry::Error => ex
+                      Chef::Log.debug("Registry error opening key '#{key}' on node #{desired}: #{ex}")
+                    end
+                  end
+                end
+              rescue ::Win32::Registry::Error => ex
+                Chef::Log.debug("Registry error opening hive '#{hkey[0]}' :: #{desired}: #{ex}")
+              end
+            end
+            entries
+          end
+
+          def self.read_registry_property(data, property)
+            data[property]
+          rescue ::Win32::Registry::Error => ex
+            Chef::Log.debug("Failure to read property '#{property}'")
+            nil
+          end
+
+          def initialize(hive, key, registry_data)
+            Chef::Log.debug("Creating uninstall entry for #{hive}::#{key}")
+            @hive = hive
+            @key = key
+            @data = registry_data
+            @display_name = RegistryUninstallEntry.read_registry_property(registry_data, 'DisplayName')
+            @display_version = RegistryUninstallEntry.read_registry_property(registry_data, 'DisplayVersion')
+            @uninstall_string = RegistryUninstallEntry.read_registry_property(registry_data, 'UninstallString')
+          end
+
+          attr_reader :hive
+          attr_reader :key
+          attr_reader :display_name
+          attr_reader :display_version
+          attr_reader :uninstall_string
+          attr_reader :data
+
+          private
+
+          UNINSTALL_SUBKEY = 'Software\Microsoft\Windows\CurrentVersion\Uninstall'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -785,19 +785,29 @@ class Chef
           def python_bin
             yum_executable = which(yum_binary)
             if yum_executable && shabang?(yum_executable)
-              extract_interpreter(yum_executable)
+              shabang_or_fallback(extract_interpreter(yum_executable))
             else
               Chef::Log.warn("Yum executable not found or doesn't start with #!. Using default python.")
               "/usr/bin/python"
             end
           rescue StandardError => e
-            Chef::Log.warn("An error occured attempting to determine correct python executable. Using default.")
+            Chef::Log.warn("An error occurred attempting to determine correct python executable. Using default.")
             Chef::Log.debug(e)
             "/usr/bin/python"
           end
 
           def extract_interpreter(file)
-            ::File.open(file, 'r', &:readline)[2..-1].chomp
+            ::File.open(file, 'r', &:readline)[2..-1].strip
+          end
+
+          # dnf based systems have a yum shim that has /bin/bash as the interpreter. Don't use this.
+          def shabang_or_fallback(interpreter)
+            if interpreter == '/bin/bash'
+              Chef::Log.warn("Yum executable interpreter is /bin/bash. Falling back to default python.")
+              "/usr/bin/python"
+            else
+              interpreter
+            end
           end
 
           def shabang?(file)

data/lib/chef/provider/powershell_script.rb

@@ -199,6 +199,9 @@ elseif ( $LASTEXITCODE -ne $null -and $LASTEXITCODE -ne 0 )
   $exitstatus = $LASTEXITCODE
 }
 
+# Print STDOUT for the script execution
+Write-Output $chefscriptresult
+
 # If this script is launched with -File, the process exit
 # status of PowerShell.exe will be $exitstatus. If it was
 # launched with -Command, it will be 0 if $exitstatus was 0,

data/lib/chef/provider/remote_file/cache_control_data.rb

@@ -145,18 +145,51 @@ class Chef
         end
 
         def load_json_data
-          Chef::FileCache.load("remote_file/#{sanitized_cache_file_basename}")
+          path = sanitized_cache_file_path(sanitized_cache_file_basename)
+          if Chef::FileCache.has_key?(path)
+            Chef::FileCache.load(path)
+          else
+            old_path = sanitized_cache_file_path(sanitized_cache_file_basename_md5)
+            if Chef::FileCache.has_key?(old_path)
+              # We found an old cache control data file. We started using sha256 instead of md5
+              # to name these. Upgrade the file to the new name.
+              Chef::Log.debug("Found old cache control data file at #{old_path}. Moving to #{path}.")
+              Chef::FileCache.load(old_path).tap do |data|
+                Chef::FileCache.store(path, data)
+                Chef::FileCache.delete(old_path)
+              end
+            else
+              raise Chef::Exceptions::FileNotFound
+            end
+          end
         end
 
-        def sanitized_cache_file_basename
+        def sanitized_cache_file_path(basename)
+          "remote_file/#{basename}"
+        end
+
+        def scrubbed_uri
           # Scrub and truncate in accordance with the goals of keeping the name
           # human-readable but within the bounds of local file system
           # path length limits
-          scrubbed_uri = uri.gsub(/\W/, '_')[0..63]
+          uri.gsub(/\W/, '_')[0..63]
+        end
+
+        def sanitized_cache_file_basename
+          uri_sha2 = Chef::Digester.instance.generate_checksum(StringIO.new(uri))
+          cache_file_basename(uri_sha2[0,32])
+        end
+
+
+        def sanitized_cache_file_basename_md5
+          # Old way of creating the file basename
           uri_md5 = Chef::Digester.instance.generate_md5_checksum(StringIO.new(uri))
-          "#{scrubbed_uri}-#{uri_md5}.json"
+          cache_file_basename(uri_md5)
         end
 
+        def cache_file_basename(checksum)
+          "#{scrubbed_uri}-#{checksum}.json"
+        end
       end
     end
   end

data/lib/chef/provider/remote_file/http.rb

@@ -105,7 +105,7 @@ class Chef
           # case you'd end up with a tar archive (no gzip) named, e.g., foo.tgz,
           # which is not what you wanted.
           if uri.to_s =~ /gz$/
-            Chef::Log.debug("turning gzip compression off due to filename ending in gz")
+            Chef::Log.debug("Turning gzip compression off due to filename ending in gz")
             opts[:disable_gzip] = true
           end
           opts

data/lib/chef/provider/script.rb

@@ -27,6 +27,7 @@ class Chef
 
       provides :bash
       provides :csh
+      provides :ksh
       provides :perl
       provides :python
       provides :ruby

data/lib/chef/provider/service.rb

@@ -44,16 +44,19 @@ class Chef
         supports[:restart] = false if supports[:restart].nil?
       end
 
-     def load_new_resource_state
-        # If the user didn't specify a change in enabled state,
-        # it will be the same as the old resource
-       if ( @new_resource.enabled.nil? )
-         @new_resource.enabled(@current_resource.enabled)
-       end
-       if ( @new_resource.running.nil? )
-         @new_resource.running(@current_resource.running)
-       end
-     end
+      # the new_resource#enabled and #running variables are not user input, but when we
+      # do (e.g.) action_enable we want to set new_resource.enabled so that the comparison
+      # between desired and current state produces the correct change in reporting.
+      # XXX?: the #nil? check below will likely fail if this is a cloned resource or if
+      # we just run multiple actions.
+      def load_new_resource_state
+        if ( @new_resource.enabled.nil? )
+          @new_resource.enabled(@current_resource.enabled)
+        end
+        if ( @new_resource.running.nil? )
+          @new_resource.running(@current_resource.running)
+        end
+      end
 
       def shared_resource_requirements
       end

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

@@ -30,35 +30,39 @@ class Chef
 
         def initialize(new_resource, run_context=nil)
           super
-          @init_command = "/usr/sbin/svcadm"
-          @status_command = "/bin/svcs -l"
+          @init_command   = "/usr/sbin/svcadm"
+          @status_command = "/bin/svcs"
           @maintenace     = false
         end
 
         def load_current_resource
           @current_resource = Chef::Resource::Service.new(@new_resource.name)
           @current_resource.service_name(@new_resource.service_name)
-          unless ::File.exists? "/bin/svcs"
-            raise Chef::Exceptions::Service, "/bin/svcs does not exist!"
+
+          [@init_command, @status_command].each do |cmd|
+            unless ::File.executable? cmd then
+              raise Chef::Exceptions::Service, "#{cmd} not executable!"
+            end
           end
           @status = service_status.enabled
+
           @current_resource
         end
 
         def enable_service
-          shell_out!("#{default_init_command} clear #{@new_resource.service_name}") if @maintenance
-          shell_out!("#{default_init_command} enable -s #{@new_resource.service_name}")
+          shell_out!(default_init_command, "clear", @new_resource.service_name) if @maintenance
+          shell_out!(default_init_command, "enable", "-s", @new_resource.service_name)
         end
 
         def disable_service
-          shell_out!("#{default_init_command} disable -s #{@new_resource.service_name}")
+          shell_out!(default_init_command, "disable", "-s", @new_resource.service_name)
         end
 
         alias_method :stop_service, :disable_service
         alias_method :start_service, :enable_service
 
         def reload_service
-          shell_out_with_systems_locale!("#{default_init_command} refresh #{@new_resource.service_name}")
+          shell_out!(default_init_command, "refresh", @new_resource.service_name)
         end
 
         def restart_service
@@ -68,16 +72,38 @@ class Chef
         end
 
         def service_status
-          status = shell_out!("#{@status_command} #{@current_resource.service_name}", :returns => [0, 1])
-          status.stdout.each_line do |line|
-            case line
-            when /state\s+online/
-              @current_resource.enabled(true)
-              @current_resource.running(true)
-            when /state\s+maintenance/
-              @maintenance = true
-            end
+          cmd = shell_out!(@status_command, "-l", @current_resource.service_name, :returns => [0, 1])
+          # Example output
+          # $ svcs -l rsyslog
+          # fmri         svc:/application/rsyslog:default
+          # name         rsyslog logging utility
+          # enabled      true
+          # state        online
+          # next_state   none
+          # state_time   April  2, 2015 04:25:19 PM EDT
+          # logfile      /var/svc/log/application-rsyslog:default.log
+          # restarter    svc:/system/svc/restarter:default
+          # contract_id  1115271
+          # dependency   require_all/error svc:/milestone/multi-user:default (online)
+          # $
+
+          # load output into hash
+          status = {}
+          cmd.stdout.each_line do |line|
+            key, value = line.strip.split(/\s+/, 2)
+            status[key] = value
+          end
+
+          # check service state
+          @maintenance = false
+          case status['state']
+          when 'online'
+            @current_resource.enabled(true)
+            @current_resource.running(true)
+          when 'maintenance'
+            @maintenance = true
           end
+
           unless @current_resource.enabled
             @current_resource.enabled(false)
             @current_resource.running(false)