chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

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

@@ -52,34 +52,30 @@ class Chef
             @package_source_found = ::File.exists?(@new_resource.source)
             if @package_source_found
               Chef::Log.debug("#{@new_resource} checking pkg status")
-              status = popen4("installp -L -d #{@new_resource.source}") do |pid, stdin, stdout, stderr|
-                package_found = false
-                stdout.each do |line|
-                  case line
-                  when /#{@new_resource.package_name}:/
-                    package_found = true
-                    fields = line.split(":")
-                    @new_resource.version(fields[2])
-                  end
+              ret = shell_out("installp -L -d #{@new_resource.source}")
+              ret.stdout.each_line do | line |
+                case line
+                when /#{@new_resource.package_name}:/
+                  fields = line.split(":")
+                  @new_resource.version(fields[2])
                 end
               end
             end
           end
 
           Chef::Log.debug("#{@new_resource} checking install state")
-          status = popen4("lslpp -lcq #{@current_resource.package_name}") do |pid, stdin, stdout, stderr|
-            stdout.each do |line|
-              case line
-              when /#{@current_resource.package_name}/
-                fields = line.split(":")
-                Chef::Log.debug("#{@new_resource} version #{fields[2]} is already installed")
-                @current_resource.version(fields[2])
-              end
+          ret = shell_out("lslpp -lcq #{@current_resource.package_name}")
+          ret.stdout.each_line do | line |
+            case line
+            when /#{@current_resource.package_name}/
+              fields = line.split(":")
+              Chef::Log.debug("#{@new_resource} version #{fields[2]} is already installed")
+              @current_resource.version(fields[2])
             end
           end
 
-          unless status.exitstatus == 0 || status.exitstatus == 1
-            raise Chef::Exceptions::Package, "lslpp failed - #{status.inspect}!"
+          unless ret.exitstatus == 0 || ret.exitstatus == 1
+            raise Chef::Exceptions::Package, "lslpp failed - #{ret.format_for_exception}!"
           end
 
           @current_resource
@@ -87,19 +83,18 @@ class Chef
 
         def candidate_version
           return @candidate_version if @candidate_version
-          status = popen4("installp -L -d #{@new_resource.source}") do |pid, stdin, stdout, stderr|
-            stdout.each_line do |line|
-              case line
-              when /\w:#{Regexp.escape(@new_resource.package_name)}:(.*)/
-                fields = line.split(":")
-                @candidate_version = fields[2]
-                @new_resource.version(fields[2])
-                Chef::Log.debug("#{@new_resource} setting install candidate version to #{@candidate_version}")
-              end
+          ret = shell_out("installp -L -d #{@new_resource.source}")
+          ret.stdout.each_line do | line |
+            case line
+            when /\w:#{Regexp.escape(@new_resource.package_name)}:(.*)/
+              fields = line.split(":")
+              @candidate_version = fields[2]
+              @new_resource.version(fields[2])
+              Chef::Log.debug("#{@new_resource} setting install candidate version to #{@candidate_version}")
             end
           end
-          unless status.exitstatus == 0
-            raise Chef::Exceptions::Package, "installp -L -d #{@new_resource.source} - #{status.inspect}!"
+          unless ret.exitstatus == 0
+            raise Chef::Exceptions::Package, "installp -L -d #{@new_resource.source} - #{ret.format_for_exception}!"
           end
           @candidate_version
         end

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

@@ -27,12 +27,18 @@ class Chef
 
         provides :apt_package, os: "linux"
 
+        # return [Hash] mapping of package name to Boolean value
         attr_accessor :is_virtual_package
 
+        def initialize(new_resource, run_context)
+          super
+          @is_virtual_package = {}
+        end
+
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)
-          check_package_state(@new_resource.package_name)
+          check_all_packages_state(@new_resource.package_name)
           @current_resource
         end
 
@@ -50,31 +56,31 @@ class Chef
           "-o APT::Default-Release=#{@new_resource.default_release}" if @new_resource.respond_to?(:default_release) && @new_resource.default_release
         end
 
-        def check_package_state(package)
-          Chef::Log.debug("#{@new_resource} checking package status for #{package}")
-          installed = false
+        def check_package_state(pkg)
+          is_virtual_package = false
+          installed          = false
+          installed_version  = nil
+          candidate_version  = nil
 
-          shell_out!("apt-cache#{expand_options(default_release_options)} policy #{package}", :timeout => @new_resource.timeout).stdout.each_line do |line|
+          shell_out!("apt-cache#{expand_options(default_release_options)} policy #{pkg}", {:timeout=>900}).stdout.each_line do |line|
             case line
             when /^\s{2}Installed: (.+)$/
               installed_version = $1
               if installed_version == '(none)'
                 Chef::Log.debug("#{@new_resource} current version is nil")
-                @current_resource.version(nil)
+                installed_version = nil
               else
                 Chef::Log.debug("#{@new_resource} current version is #{installed_version}")
-                @current_resource.version(installed_version)
                 installed = true
               end
             when /^\s{2}Candidate: (.+)$/
               candidate_version = $1
               if candidate_version == '(none)'
                 # This may not be an appropriate assumption, but it shouldn't break anything that already worked -- btm
-                @is_virtual_package = true
-                showpkg = shell_out!("apt-cache showpkg #{package}", :timeout => @new_resource.timeout).stdout
+                is_virtual_package = true
+                showpkg = shell_out!("apt-cache showpkg #{pkg}", {:timeout => 900}).stdout
                 providers = Hash.new
-                # Returns all lines after 'Reverse Provides:'
-                showpkg.rpartition(/Reverse Provides:\s*#{$/}/)[2].each_line do |line|
+                showpkg.rpartition(/Reverse Provides: ?#{$/}/)[2].each_line do |line|
                   provider, version = line.split
                   providers[provider] = version
                 end
@@ -85,20 +91,56 @@ class Chef
                 raise Chef::Exceptions::Package, "#{@new_resource.package_name} is a virtual package provided by #{num_providers} packages, you must explicitly select one to install" if num_providers > 1
                 # Check if the package providing this virtual package is installed
                 Chef::Log.info("#{@new_resource} is a virtual package, actually acting on package[#{providers.keys.first}]")
-                installed = check_package_state(providers.keys.first)
+                ret = check_package_state(providers.keys.first)
+                installed = ret[:installed]
+                installed_version = ret[:installed_version]
               else
                 Chef::Log.debug("#{@new_resource} candidate version is #{$1}")
-                @candidate_version = $1
               end
             end
           end
 
-          return installed
+          return {
+            installed_version:   installed_version,
+            installed:           installed,
+            candidate_version:   candidate_version,
+            is_virtual_package:  is_virtual_package,
+          }
+        end
+
+        def check_all_packages_state(package)
+          installed_version = {}
+          candidate_version = {}
+          installed = {}
+
+          [package].flatten.each do |pkg|
+            ret = check_package_state(pkg)
+            is_virtual_package[pkg] = ret[:is_virtual_package]
+            installed[pkg]          = ret[:installed]
+            installed_version[pkg]  = ret[:installed_version]
+            candidate_version[pkg]  = ret[:candidate_version]
+          end
+
+          if package.is_a?(Array)
+            @candidate_version = []
+            final_installed_version = []
+            [package].flatten.each do |pkg|
+              @candidate_version << candidate_version[pkg]
+              final_installed_version << installed_version[pkg]
+            end
+            @current_resource.version(final_installed_version)
+          else
+            @candidate_version = candidate_version[package]
+            @current_resource.version(installed_version[package])
+          end
         end
 
         def install_package(name, version)
-          package_name = "#{name}=#{version}"
-          package_name = name if @is_virtual_package
+          name_array = [ name ].flatten
+          version_array = [ version ].flatten
+          package_name = name_array.zip(version_array).map do |n, v|
+            is_virtual_package[n] ? n : "#{n}=#{v}"
+          end.join(' ')
           run_noninteractive("apt-get -q -y#{expand_options(default_release_options)}#{expand_options(@new_resource.options)} install #{package_name}")
         end
 
@@ -107,12 +149,13 @@ class Chef
         end
 
         def remove_package(name, version)
-          package_name = "#{name}"
+          package_name = [ name ].flatten.join(' ')
           run_noninteractive("apt-get -q -y#{expand_options(@new_resource.options)} remove #{package_name}")
         end
 
         def purge_package(name, version)
-          run_noninteractive("apt-get -q -y#{expand_options(@new_resource.options)} purge #{@new_resource.package_name}")
+          package_name = [ name ].flatten.join(' ')
+          run_noninteractive("apt-get -q -y#{expand_options(@new_resource.options)} purge #{package_name}")
         end
 
         def preseed_package(preseed_file)
@@ -121,8 +164,9 @@ class Chef
         end
 
         def reconfig_package(name, version)
+          package_name = [ name ].flatten.join(' ')
           Chef::Log.info("#{@new_resource} reconfiguring")
-          run_noninteractive("dpkg-reconfigure #{name}")
+          run_noninteractive("dpkg-reconfigure #{package_name}")
         end
 
         private

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

@@ -61,12 +61,12 @@ class Chef
             if @source_exists
               # Get information from the package if supplied
               Chef::Log.debug("#{@new_resource} checking dpkg status")
-              status = popen4("dpkg-deb -W #{@new_resource.source}") do |pid, stdin, stdout, stderr|
-                stdout.each_line do |line|
-                  if pkginfo = DPKG_INFO.match(line)
-                    @current_resource.package_name(pkginfo[1])
-                    @new_resource.version(pkginfo[2])
-                  end
+
+              shell_out("dpkg-deb -W #{@new_resource.source}").stdout.each_line do |line|
+                if pkginfo = DPKG_INFO.match(line)
+                  @current_resource.package_name(pkginfo[1])
+                  @new_resource.version(pkginfo[2])
+                  @candidate_version = pkginfo[2]
                 end
               end
             else
@@ -79,16 +79,15 @@ class Chef
           # Check to see if it is installed
           package_installed = nil
           Chef::Log.debug("#{@new_resource} checking install state")
-          status = popen4("dpkg -s #{@current_resource.package_name}") do |pid, stdin, stdout, stderr|
-            stdout.each_line do |line|
-              case line
-              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)
-                end
+          status = shell_out("dpkg -s #{@current_resource.package_name}")
+          status.stdout.each_line do |line|
+            case line
+            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)
               end
             end
           end

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

@@ -3,7 +3,8 @@ class Chef
     class Package
       class Macports < Chef::Provider::Package
 
-        provides :macports_package, os: "mac_os_x"
+        provides :macports_package
+        provides :package, os: "darwin"
 
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
@@ -82,12 +83,11 @@ class Chef
         private
         def get_response_from_command(command)
           output = nil
-          status = popen4(command) do |pid, stdin, stdout, stderr|
-            begin
-              output = stdout.read
-            rescue Exception
-              raise Chef::Exceptions::Package, "Could not read from STDOUT on command: #{command}"
-            end
+          status = shell_out(command)
+          begin
+            output = status.stdout
+          rescue Exception
+            raise Chef::Exceptions::Package, "Could not read from STDOUT on command: #{command}"
           end
           unless status.exitstatus == 0 || status.exitstatus == 1
             raise Chef::Exceptions::Package, "#{command} failed - #{status.insect}!"

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

@@ -0,0 +1,107 @@
+#
+# Authors:: Bryan McLellan (btm@loftninjas.org)
+#           Matthew Landauer (matthew@openaustralia.org)
+#           Richard Manyanza (liseki@nyikacraftsmen.com)
+#           Scott Bonds (scott@ggr.com)
+# Copyright:: Copyright (c) 2009 Bryan McLellan, Matthew Landauer
+# Copyright:: Copyright (c) 2014 Richard Manyanza, Scott Bonds
+# 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/resource/package'
+require 'chef/provider/package'
+require 'chef/mixin/shell_out'
+require 'chef/mixin/get_source_from_package'
+
+class Chef
+  class Provider
+    class Package
+      class Openbsd < Chef::Provider::Package
+
+        provides :package, os: "openbsd"
+
+        include Chef::Mixin::ShellOut
+        include Chef::Mixin::GetSourceFromPackage
+
+        def initialize(*args)
+          super
+          @current_resource = Chef::Resource::Package.new(@new_resource.name)
+          @new_resource.source(pkg_path) if !@new_resource.source
+        end
+
+        def load_current_resource
+          @current_resource.package_name(@new_resource.package_name)
+          @current_resource.version(installed_version)
+          @current_resource
+        end
+
+        def install_package(name, version)
+          unless @current_resource.version
+            version_string  = ''
+            version_string += "-#{version}" if version
+            if parts = name.match(/^(.+?)--(.+)/) # use double-dash for stems with flavors, see man page for pkg_add
+              name = parts[1]
+            end
+            shell_out!("pkg_add -r #{name}#{version_string}", :env => {"PKG_PATH" => @new_resource.source}).status
+            Chef::Log.debug("#{@new_resource} installed from: #{@new_resource.source}")
+          end
+        end
+
+        def remove_package(name, version)
+          version_string  = ''
+          version_string += "-#{version}" if version
+          if parts = name.match(/^(.+?)--(.+)/)
+            name = parts[1]
+          end
+          shell_out!("pkg_delete #{name}#{version_string}", :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!("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
+        end
+
+        def candidate_version
+          @candidate_version ||= begin
+            version_string  = ''
+            version_string += "-#{version}" if @new_resource.version
+            pkg_info = shell_out!("pkg_info -I \"#{@new_resource.package_name}#{version_string}\"", :env => nil, :returns => [0,1])
+            if parts = @new_resource.package_name.match(/^(.+?)--(.+)/)
+              result = pkg_info.stdout[/^#{Regexp.escape(parts[1])}-(.+?)\s/, 1]
+            else
+              result = pkg_info.stdout[/^#{Regexp.escape(@new_resource.package_name)}-(.+?)\s/, 1]
+            end
+            Chef::Log.debug("candidate_version of '#{@new_resource.package_name}' is '#{result}'")
+            result
+          end
+        end
+
+        def pkg_path
+          ENV['PKG_PATH'] || "http://ftp.OpenBSD.org/pub/#{node.kernel.name}/#{node.kernel.release}/packages/#{node.kernel.machine}/"
+        end
+
+      end
+    end
+  end
+end

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

@@ -34,13 +34,12 @@ class Chef
           @current_resource.version(nil)
 
           Chef::Log.debug("#{@new_resource} checking pacman for #{@new_resource.package_name}")
-          status = popen4("pacman -Qi #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
-            stdout.each do |line|
-              case line
-              when /^Version(\s?)*: (.+)$/
-                Chef::Log.debug("#{@new_resource} current version is #{$2}")
-                @current_resource.version($2)
-              end
+          status = shell_out("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)
             end
           end
 
@@ -63,14 +62,13 @@ class Chef
 
           package_repos = repos.map {|r| Regexp.escape(r) }.join('|')
 
-          status = popen4("pacman -Sl") do |pid, stdin, stdout, stderr|
-            stdout.each 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
-              end
+          status = shell_out("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
             end
           end