chef 12.6.0 → 12.7.2

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

@@ -1,6 +1,6 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,9 +16,9 @@
 # limitations under the License.
 #
 
-require 'chef/provider/package'
-require 'chef/mixin/command'
-require 'chef/resource/package'
+require "chef/provider/package"
+require "chef/mixin/command"
+require "chef/resource/package"
 
 class Chef
   class Provider
@@ -48,7 +48,7 @@ class Chef
 
           requirements.assert(:all_actions) do |a|
             a.assertion { !@new_resource.source }
-            a.failure_message(Chef::Exceptions::Package, 'apt package provider cannot handle source attribute. Use dpkg provider instead')
+            a.failure_message(Chef::Exceptions::Package, "apt package provider cannot handle source attribute. Use dpkg provider instead")
           end
         end
 
@@ -67,7 +67,7 @@ class Chef
             case line
             when /^\s{2}Installed: (.+)$/
               installed_version = $1
-              if installed_version == '(none)'
+              if installed_version == "(none)"
                 Chef::Log.debug("#{@new_resource} current version is nil")
                 installed_version = nil
               else
@@ -76,7 +76,7 @@ class Chef
               end
             when /^\s{2}Candidate: (.+)$/
               candidate_version = $1
-              if candidate_version == '(none)'
+              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_with_timeout!("apt-cache showpkg #{pkg}").stdout
@@ -141,7 +141,7 @@ class Chef
           version_array = [ version ].flatten
           package_name = name_array.zip(version_array).map do |n, v|
             is_virtual_package[n] ? n : "#{n}=#{v}"
-          end.join(' ')
+          end.join(" ")
           run_noninteractive("apt-get -q -y#{expand_options(default_release_options)}#{expand_options(@new_resource.options)} install #{package_name}")
         end
 
@@ -150,12 +150,12 @@ class Chef
         end
 
         def remove_package(name, version)
-          package_name = [ name ].flatten.join(' ')
+          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)
-          package_name = [ name ].flatten.join(' ')
+          package_name = [ name ].flatten.join(" ")
           run_noninteractive("apt-get -q -y#{expand_options(@new_resource.options)} purge #{package_name}")
         end
 
@@ -165,7 +165,7 @@ class Chef
         end
 
         def reconfig_package(name, version)
-          package_name = [ name ].flatten.join(' ')
+          package_name = [ name ].flatten.join(" ")
           Chef::Log.info("#{@new_resource} reconfiguring")
           run_noninteractive("dpkg-reconfigure #{package_name}")
         end

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

@@ -0,0 +1,277 @@
+#
+# Copyright:: Copyright 2015-2016, 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/provider/package"
+require "chef/resource/chocolatey_package"
+require "chef/mixin/powershell_out"
+
+class Chef
+  class Provider
+    class Package
+      class Chocolatey < Chef::Provider::Package
+        include Chef::Mixin::PowershellOut
+
+        provides :chocolatey_package, os: "windows"
+
+        # Declare that our arguments should be arrays
+        use_multipackage_api
+
+        PATHFINDING_POWERSHELL_COMMAND = "[System.Environment]::GetEnvironmentVariable('ChocolateyInstall', 'MACHINE')"
+        CHOCO_MISSING_MSG = <<-EOS
+Could not locate your Chocolatey install. To install chocolatey, we recommend
+the 'chocolatey' cookbook (https://github.com/chocolatey/chocolatey-cookbook).
+If Chocolatey is installed, ensure that the 'ChocolateyInstall' environment
+variable is correctly set. You can verify this with the PowerShell command
+'#{PATHFINDING_POWERSHELL_COMMAND}'.
+EOS
+
+        # Responsible for building the current_resource.
+        #
+        # @return [Chef::Resource::ChocolateyPackage] the current_resource
+        def load_current_resource
+          @current_resource = Chef::Resource::ChocolateyPackage.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
+          current_resource.version(build_current_versions)
+          current_resource
+        end
+
+        def define_resource_requirements
+          super
+
+          requirements.assert(:all_actions) do |a|
+            # GetEnvironmentVariable returns "" on failure.
+            a.assertion { !choco_install_path.to_s.empty? }
+            a.failure_message(Chef::Exceptions::MissingLibrary, CHOCO_MISSING_MSG)
+            a.whyrun("Assuming Chocolatey is installed")
+          end
+
+          # Chocolatey source attribute points to an alternate feed
+          # and not a package specific alternate source like other providers
+          # so we want to assert candidates exist for the alternate source
+          requirements.assert(:upgrade, :install) do |a|
+            a.assertion { candidates_exist_for_all_uninstalled? }
+            a.failure_message(Chef::Exceptions::Package, "No candidate version available for #{packages_missing_candidates.join(", ")}")
+            a.whyrun("Assuming a repository that offers #{packages_missing_candidates.join(", ")} would have been configured")
+          end
+        end
+
+        # Lazy initializer for candidate_version.  A nil value means that there is no candidate
+        # version and the package is not installable (generally an error).
+        #
+        # @return [Array] list of candidate_versions indexed same as new_resource.package_name/version
+        def candidate_version
+          @candidate_version ||= build_candidate_versions
+        end
+
+        # Install multiple packages via choco.exe
+        #
+        # @param names [Array<String>] array of package names to install
+        # @param versions [Array<String>] array of versions to install
+        def install_package(names, versions)
+          name_versions_to_install = desired_name_versions.select { |n, v| lowercase_names(names).include?(n) }
+
+          name_nil_versions = name_versions_to_install.select { |n, v| v.nil? }
+          name_has_versions = name_versions_to_install.reject { |n, v| v.nil? }
+
+          # choco does not support installing multiple packages with version pins
+          name_has_versions.each do |name, version|
+            choco_command("install -y -version", version, cmd_args, name)
+          end
+
+          # but we can do all the ones without version pins at once
+          unless name_nil_versions.empty?
+            cmd_names = name_nil_versions.keys
+            choco_command("install -y", cmd_args, *cmd_names)
+          end
+        end
+
+        # Upgrade multiple packages via choco.exe
+        #
+        # @param names [Array<String>] array of package names to install
+        # @param versions [Array<String>] array of versions to install
+        def upgrade_package(names, versions)
+          name_versions_to_install = desired_name_versions.select { |n, v| lowercase_names(names).include?(n) }
+
+          name_nil_versions = name_versions_to_install.select { |n, v| v.nil? }
+          name_has_versions = name_versions_to_install.reject { |n, v| v.nil? }
+
+          # choco does not support installing multiple packages with version pins
+          name_has_versions.each do |name, version|
+            choco_command("upgrade -y -version", version, cmd_args, name)
+          end
+
+          # but we can do all the ones without version pins at once
+          unless name_nil_versions.empty?
+            cmd_names = name_nil_versions.keys
+            choco_command("upgrade -y", cmd_args, *cmd_names)
+          end
+        end
+
+        # Remove multiple packages via choco.exe
+        #
+        # @param names [Array<String>] array of package names to install
+        # @param versions [Array<String>] array of versions to install
+        def remove_package(names, versions)
+          choco_command("uninstall -y", cmd_args, *names)
+        end
+
+        # Support :uninstall as an action in order for users to easily convert
+        # from the `chocolatey` provider in the cookbook.  It is, however,
+        # already deprecated.
+        def action_uninstall
+          Chef::Log.deprecation "The use of action :uninstall on the chocolatey_package provider is deprecated, please use :remove"
+          action_remove
+        end
+
+        # Choco does not have dpkg's distinction between purge and remove
+        alias_method :purge_package, :remove_package
+
+        # Override the superclass check.  The semantics for our new_resource.source is not files to
+        # install from, but like the rubygem provider's sources which are more like repos.
+        def check_resource_semantics!
+        end
+
+        private
+
+        # Magic to find where chocolatey is installed in the system, and to
+        # return the full path of choco.exe
+        #
+        # @return [String] full path of choco.exe
+        def choco_exe
+          @choco_exe ||= ::File.join(
+            choco_install_path,
+            "bin",
+            "choco.exe",
+            )
+        end
+
+        # lets us mock out an incorrect value for testing.
+        def choco_install_path
+          @choco_install_path ||= powershell_out!(
+            PATHFINDING_POWERSHELL_COMMAND
+            ).stdout.chomp
+        end
+
+        # Helper to dispatch a choco command through shell_out using the timeout
+        # set on the new resource, with nice command formatting.
+        #
+        # @param args [String] variable number of string arguments
+        # @return [Mixlib::ShellOut] object returned from shell_out!
+        def choco_command(*args)
+          shell_out_with_timeout!(args_to_string(choco_exe, *args))
+        end
+
+        # Use the available_packages Hash helper to create an array suitable for
+        # using in candidate_version
+        #
+        # @return [Array] list of candidate_version, same index as new_resource.package_name/version
+        def build_candidate_versions
+          new_resource.package_name.map do |package_name|
+            available_packages[package_name.downcase]
+          end
+        end
+
+        # Use the installed_packages Hash helper to create an array suitable for
+        # using in current_resource.version
+        #
+        # @return [Array] list of candidate_version, same index as new_resource.package_name/version
+        def build_current_versions
+          new_resource.package_name.map do |package_name|
+            installed_packages[package_name.downcase]
+          end
+        end
+
+        # Helper to construct Hash of names-to-versions, requested on the new_resource.
+        # If new_resource.version is nil, then all values will be nil.
+        #
+        # @return [Hash] Mapping of requested names to versions
+        def desired_name_versions
+          desired_versions = new_resource.version || new_resource.package_name.map { nil }
+          Hash[*lowercase_names(new_resource.package_name).zip(desired_versions).flatten]
+        end
+
+        # Helper to construct optional args out of new_resource
+        #
+        # @return [String] options from new_resource or empty string
+        def cmd_args
+          cmd_args = [ new_resource.options ]
+          cmd_args.push( "-source #{new_resource.source}" ) if new_resource.source
+          args_to_string(*cmd_args)
+        end
+
+        # Helper to nicely convert variable string args into a single command line.  It
+        # will compact nulls or empty strings and join arguments with single spaces, without
+        # introducing any double-spaces for missing args.
+        #
+        # @param args [String] variable number of string arguments
+        # @return [String] nicely concatenated string or empty string
+        def args_to_string(*args)
+          args.reject { |i| i.nil? || i == "" }.join(" ")
+        end
+
+        # Available packages in chocolatey as a Hash of names mapped to versions
+        # If pinning a package to a specific version, filter out all non matching versions
+        # (names are downcased for case-insensitive matching)
+        #
+        # @return [Hash] name-to-version mapping of available packages
+        def available_packages
+          @available_packages ||=
+            begin
+              cmd = [ "list -ar #{package_name_array.join ' '}" ]
+              cmd.push( "-source #{new_resource.source}" ) if new_resource.source
+              parse_list_output(*cmd).each_with_object({}) do |name_version, available|
+                name, version = name_version
+                if desired_name_versions[name].nil? || desired_name_versions[name] == version
+                  available[name] = version
+                end
+              end
+            end
+        end
+
+        # Installed packages in chocolatey as a Hash of names mapped to versions
+        # (names are downcased for case-insensitive matching)
+        #
+        # @return [Hash] name-to-version mapping of installed packages
+        def installed_packages
+          @installed_packages ||= Hash[*parse_list_output("list -l -r").flatten]
+        end
+
+        # Helper to convert choco.exe list output to a Hash
+        # (names are downcased for case-insenstive matching)
+        #
+        # @param cmd [String] command to run
+        # @return [Array] list output converted to ruby Hash
+        def parse_list_output(*args)
+          list = []
+          choco_command(*args).stdout.each_line do |line|
+            name, version = line.split("|")
+            list << [ name.downcase, version.chomp ]
+          end
+          list
+        end
+
+        # Helper to downcase all names in an array
+        #
+        # @param names [Array] original mixed case names
+        # @return [Array] same names in lower case
+        def lowercase_names(names)
+          names.map { |name| name.downcase }
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 #
 # Author:: Bryan McLellan (btm@loftninjas.org)
-# Copyright:: Copyright (c) 2009 Bryan McLellan
+# Copyright:: Copyright 2009-2016, Bryan McLellan
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'chef/provider/package'
-require 'chef/resource/package'
+require "chef/provider/package"
+require "chef/resource/package"
 
 class Chef
   class Provider
@@ -145,14 +145,14 @@ class Chef
         #
         # @return [Boolean] True if all sources exist
         def source_files_exist?
-          resolved_source_array.all? {|s| s && ::File.exist?(s) }
+          resolved_source_array.all? { |s| s && ::File.exist?(s) }
         end
 
         # 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) }
+          resolved_source_array.select { |s| s.nil? || !::File.exist?(s) }
         end
 
         def current_package_name_array
@@ -187,14 +187,14 @@ class Chef
         def name_candidate_version
           @name_candidate_version ||=
             begin
-              Hash[name_pkginfo.map {|k, v| [k, v ? v.split("\t")[1].strip : nil] }]
+              Hash[name_pkginfo.map { |k, v| [k, v ? v.split("\t")[1].strip : nil] }]
             end
         end
 
         def name_package_name
           @name_package_name ||=
             begin
-              Hash[name_pkginfo.map {|k, v| [k, v ? v.split("\t")[0] : nil] }]
+              Hash[name_pkginfo.map { |k, v| [k, v ? v.split("\t")[0] : nil] }]
             end
         end
 

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

@@ -1,6 +1,6 @@
 #
 # Author:: Joe Williams (<joe@joetify.com>)
-# Copyright:: Copyright (c) 2009 Joe Williams
+# Copyright:: Copyright 2009-2016, Joe Williams
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,9 +16,9 @@
 # limitations under the License.
 #
 
-require 'chef/provider/package'
-require 'chef/mixin/command'
-require 'chef/resource/package'
+require "chef/provider/package"
+require "chef/mixin/command"
+require "chef/resource/package"
 
 class Chef
   class Provider
@@ -32,10 +32,10 @@ class Chef
 
           begin
             # first check to see if we can import it
-            output = shell_out_with_timeout!("#{python_binary_path} -c \"import #{name}\"", :returns=>[0,1]).stderr
+            output = shell_out_with_timeout!("#{python_binary_path} -c \"import #{name}\"", :returns => [0, 1]).stderr
             if output.include? "ImportError"
               # then check to see if its on the path
-              output = shell_out_with_timeout!("#{python_binary_path} -c \"import sys; print sys.path\"", :returns=>[0,1]).stdout
+              output = shell_out_with_timeout!("#{python_binary_path} -c \"import sys; print sys.path\"", :returns => [0, 1]).stdout
               if output.downcase.include? "#{name.downcase}"
                 check = true
               end
@@ -51,12 +51,12 @@ class Chef
 
         def easy_install_binary_path
           path = @new_resource.easy_install_binary
-          path ? path : 'easy_install'
+          path ? path : "easy_install"
         end
 
         def python_binary_path
           path = @new_resource.python_binary
-          path ? path : 'python'
+          path ? path : "python"
         end
 
         def module_name
@@ -67,7 +67,6 @@ class Chef
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)
-          @current_resource.version(nil)
 
           # get the currently installed version if installed
           package_version = nil
@@ -76,9 +75,9 @@ class Chef
               output = shell_out_with_timeout!("#{python_binary_path} -c \"import #{module_name}; print #{module_name}.__version__\"").stdout
               package_version = output.strip
             rescue
-              output = shell_out_with_timeout!("#{python_binary_path} -c \"import sys; print sys.path\"", :returns=>[0,1]).stdout
+              output = shell_out_with_timeout!("#{python_binary_path} -c \"import sys; print sys.path\"", :returns => [0, 1]).stdout
 
-              output_array = output.gsub(/[\[\]]/,'').split(/\s*,\s*/)
+              output_array = output.gsub(/[\[\]]/, "").split(/\s*,\s*/)
               package_path = ""
 
               output_array.each do |entry|
@@ -104,12 +103,12 @@ class Chef
         end
 
         def candidate_version
-           return @candidate_version if @candidate_version
+          return @candidate_version if @candidate_version
 
            # do a dry run to get the latest version
-           result = shell_out_with_timeout!("#{easy_install_binary_path} -n #{@new_resource.package_name}", :returns=>[0,1])
-           @candidate_version = result.stdout[/(.*)Best match: (.*) (.*)$/, 3]
-           @candidate_version
+          result = shell_out_with_timeout!("#{easy_install_binary_path} -n #{@new_resource.package_name}", :returns => [0, 1])
+          @candidate_version = result.stdout[/(.*)Best match: (.*) (.*)$/, 3]
+          @candidate_version
         end
 
         def install_package(name, version)