chef 12.17.44-universal-mingw32 → 12.18.31-universal-mingw32

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

@@ -25,61 +25,56 @@ class Chef
         provides :ifconfig, platform: %w{aix}
 
         def load_current_resource
-          @current_resource = Chef::Resource::Ifconfig.new(@new_resource.name)
+          @current_resource = Chef::Resource::Ifconfig.new(new_resource.name)
 
           @interface_exists = false
           found_interface = false
           interface = {}
 
-          @status = shell_out("ifconfig -a")
+          @status = shell_out_compact("ifconfig", "-a")
           @status.stdout.each_line do |line|
             if !found_interface
               if line =~ /^(\S+):\sflags=(\S+)/
-                # We have interface name, if this is the interface for @current_resource, load info else skip till next interface is found.
-                if $1 == @new_resource.device
+                # We have interface name, if this is the interface for current_resource, load info else skip till next interface is found.
+                if Regexp.last_match(1) == new_resource.device
                   # Found interface
                   found_interface = true
                   @interface_exists = true
-                  @current_resource.target(@new_resource.target)
-                  @current_resource.device($1)
-                  interface[:flags] = $2
-                  @current_resource.metric($1) if line =~ /metric\s(\S+)/
-                end
-              end
-            else
-              # parse interface related information, stop when next interface is found.
-              if line =~ /^(\S+):\sflags=(\S+)/
-                # we are done parsing interface info and hit another one, so stop.
-                found_interface = false
-                break
-              else
-                if found_interface
-                  # read up interface info
-                  @current_resource.inet_addr($1) if line =~ /inet\s(\S+)\s/
-                  @current_resource.bcast($1) if line =~ /broadcast\s(\S+)/
-                  @current_resource.mask(hex_to_dec_netmask($1)) if line =~ /netmask\s(\S+)\s/
+                  current_resource.target(new_resource.target)
+                  current_resource.device(Regexp.last_match(1))
+                  interface[:flags] = Regexp.last_match(2)
+                  current_resource.metric(Regexp.last_match(1)) if line =~ /metric\s(\S+)/
                 end
               end
+            elsif line =~ /^(\S+):\sflags=(\S+)/
+              # we are done parsing interface info and hit another one, so stop.
+              found_interface = false
+              break
+            elsif found_interface
+              # read up interface info
+              current_resource.inet_addr(Regexp.last_match(1)) if line =~ /inet\s(\S+)\s/
+              current_resource.bcast(Regexp.last_match(1)) if line =~ /broadcast\s(\S+)/
+              current_resource.mask(hex_to_dec_netmask(Regexp.last_match(1))) if line =~ /netmask\s(\S+)\s/
             end
           end
 
-          @current_resource
+          current_resource
         end
 
         private
 
         def add_command
           # ifconfig changes are temporary, chdev persist across reboots.
-          raise Chef::Exceptions::Ifconfig, "interface metric attribute cannot be set for :add action" if @new_resource.metric
-          command = "chdev -l #{@new_resource.device} -a netaddr=#{@new_resource.name}"
-          command << " -a netmask=#{@new_resource.mask}" if @new_resource.mask
-          command << " -a mtu=#{@new_resource.mtu}" if @new_resource.mtu
+          raise Chef::Exceptions::Ifconfig, "interface metric attribute cannot be set for :add action" if new_resource.metric
+          command = [ "chdev", "-l", new_resource.device, "-a", "netaddr=#{new_resource.name}" ]
+          command += [ "-a", "netmask=#{new_resource.mask}" ] if new_resource.mask
+          command += [ "-a", "mtu=#{new_resource.mtu}" ] if new_resource.mtu
           command
         end
 
         def delete_command
           # ifconfig changes are temporary, chdev persist across reboots.
-          "chdev -l #{@new_resource.device} -a state=down"
+          [ "chdev", "-l", new_resource.device, "-a", "state=down" ]
         end
 
         def loopback_device

data/lib/chef/provider/ifconfig/debian.rb

@@ -26,32 +26,32 @@ class Chef
         provides :ifconfig, platform: %w{ubuntu}, platform_version: ">= 11.10"
         provides :ifconfig, platform: %w{debian}, platform_version: ">= 7.0"
 
-        INTERFACES_FILE = "/etc/network/interfaces"
-        INTERFACES_DOT_D_DIR = "/etc/network/interfaces.d"
+        INTERFACES_FILE = "/etc/network/interfaces".freeze
+        INTERFACES_DOT_D_DIR = "/etc/network/interfaces.d".freeze
 
         def initialize(new_resource, run_context)
           super(new_resource, run_context)
           @config_template = %{
-<% if @new_resource.device %>
-<% if @new_resource.onboot == "yes" %>auto <%= @new_resource.device %><% end %>
-<% case @new_resource.bootproto
+<% if new_resource.device %>
+<% if new_resource.onboot == "yes" %>auto <%= new_resource.device %><% end %>
+<% case new_resource.bootproto
    when "dhcp" %>
-iface <%= @new_resource.device %> inet dhcp
+iface <%= new_resource.device %> inet dhcp
 <% when "bootp" %>
-iface <%= @new_resource.device %> inet bootp
+iface <%= new_resource.device %> inet bootp
 <% else %>
-iface <%= @new_resource.device %> inet static
-    <% if @new_resource.target %>address <%= @new_resource.target %><% end %>
-    <% if @new_resource.mask %>netmask <%= @new_resource.mask %><% end %>
-    <% if @new_resource.network %>network <%= @new_resource.network %><% end %>
-    <% if @new_resource.bcast %>broadcast <%= @new_resource.bcast %><% end %>
-    <% if @new_resource.metric %>metric <%= @new_resource.metric %><% end %>
-    <% if @new_resource.hwaddr %>hwaddress <%= @new_resource.hwaddr %><% end %>
-    <% if @new_resource.mtu %>mtu <%= @new_resource.mtu %><% end %>
+iface <%= new_resource.device %> inet static
+    <% if new_resource.target %>address <%= new_resource.target %><% end %>
+    <% if new_resource.mask %>netmask <%= new_resource.mask %><% end %>
+    <% if new_resource.network %>network <%= new_resource.network %><% end %>
+    <% if new_resource.bcast %>broadcast <%= new_resource.bcast %><% end %>
+    <% if new_resource.metric %>metric <%= new_resource.metric %><% end %>
+    <% if new_resource.hwaddr %>hwaddress <%= new_resource.hwaddr %><% end %>
+    <% if new_resource.mtu %>mtu <%= new_resource.mtu %><% end %>
 <% end %>
 <% end %>
           }
-          @config_path = "#{INTERFACES_DOT_D_DIR}/ifcfg-#{@new_resource.device}"
+          @config_path = "#{INTERFACES_DOT_D_DIR}/ifcfg-#{new_resource.device}"
         end
 
         def generate_config
@@ -69,12 +69,13 @@ iface <%= @new_resource.device %> inet static
           # roll our own file_edit resource, this will not get reported until we have a file_edit resource
           interfaces_dot_d_for_regexp = INTERFACES_DOT_D_DIR.gsub(/\./, '\.') # escape dots for the regexp
           regexp = %r{^\s*source\s+#{interfaces_dot_d_for_regexp}/\*\s*$}
-          unless ::File.exists?(INTERFACES_FILE) && regexp.match(IO.read(INTERFACES_FILE))
-            converge_by("modifying #{INTERFACES_FILE} to source #{INTERFACES_DOT_D_DIR}") do
-              conf = Chef::Util::FileEdit.new(INTERFACES_FILE)
-              conf.insert_line_if_no_match(regexp, "source #{INTERFACES_DOT_D_DIR}/*")
-              conf.write_file
-            end
+
+          return if ::File.exist?(INTERFACES_FILE) && regexp.match(IO.read(INTERFACES_FILE))
+
+          converge_by("modifying #{INTERFACES_FILE} to source #{INTERFACES_DOT_D_DIR}") do
+            conf = Chef::Util::FileEdit.new(INTERFACES_FILE)
+            conf.insert_line_if_no_match(regexp, "source #{INTERFACES_DOT_D_DIR}/*")
+            conf.write_file
           end
         end
 

data/lib/chef/provider/ifconfig/redhat.rb

@@ -27,19 +27,19 @@ class Chef
         def initialize(new_resource, run_context)
           super(new_resource, run_context)
           @config_template = %{
-<% if @new_resource.device %>DEVICE=<%= @new_resource.device %><% end %>
-<% if @new_resource.onboot == "yes" %>ONBOOT=<%= @new_resource.onboot %><% end %>
-<% if @new_resource.bootproto %>BOOTPROTO=<%= @new_resource.bootproto %><% end %>
-<% if @new_resource.target %>IPADDR=<%= @new_resource.target %><% end %>
-<% if @new_resource.mask %>NETMASK=<%= @new_resource.mask %><% end %>
-<% if @new_resource.network %>NETWORK=<%= @new_resource.network %><% end %>
-<% if @new_resource.bcast %>BROADCAST=<%= @new_resource.bcast %><% end %>
-<% if @new_resource.onparent %>ONPARENT=<%= @new_resource.onparent %><% end %>
-<% if @new_resource.hwaddr %>HWADDR=<%= @new_resource.hwaddr %><% end %>
-<% if @new_resource.metric %>METRIC=<%= @new_resource.metric %><% end %>
-<% if @new_resource.mtu %>MTU=<%= @new_resource.mtu %><% end %>
+<% if new_resource.device %>DEVICE=<%= new_resource.device %><% end %>
+<% if new_resource.onboot == "yes" %>ONBOOT=<%= new_resource.onboot %><% end %>
+<% if new_resource.bootproto %>BOOTPROTO=<%= new_resource.bootproto %><% end %>
+<% if new_resource.target %>IPADDR=<%= new_resource.target %><% end %>
+<% if new_resource.mask %>NETMASK=<%= new_resource.mask %><% end %>
+<% if new_resource.network %>NETWORK=<%= new_resource.network %><% end %>
+<% if new_resource.bcast %>BROADCAST=<%= new_resource.bcast %><% end %>
+<% if new_resource.onparent %>ONPARENT=<%= new_resource.onparent %><% end %>
+<% if new_resource.hwaddr %>HWADDR=<%= new_resource.hwaddr %><% end %>
+<% if new_resource.metric %>METRIC=<%= new_resource.metric %><% end %>
+<% if new_resource.mtu %>MTU=<%= new_resource.mtu %><% end %>
           }
-          @config_path = "/etc/sysconfig/network-scripts/ifcfg-#{@new_resource.device}"
+          @config_path = "/etc/sysconfig/network-scripts/ifcfg-#{new_resource.device}"
         end
 
       end

data/lib/chef/provider/mount/mount.rb

@@ -210,7 +210,7 @@ class Chef
         end
 
         def device_real
-          if @real_device == nil
+          if @real_device.nil?
             if @new_resource.device_type == :device
               @real_device = @new_resource.device
             else

data/lib/chef/provider/osx_profile.rb

@@ -44,8 +44,10 @@ class Chef
         )
 
         @new_profile_hash = get_profile_hash(@new_resource.profile)
-        @new_profile_hash["PayloadUUID"] =
-          config_uuid(@new_profile_hash) if @new_profile_hash
+        if @new_profile_hash
+          @new_profile_hash["PayloadUUID"] =
+            config_uuid(@new_profile_hash)
+        end
 
         if @new_profile_hash
           @new_profile_identifier = @new_profile_hash["PayloadIdentifier"]

data/lib/chef/provider/package.rb

@@ -37,6 +37,9 @@ class Chef
       subclass_directive :use_multipackage_api
       # subclasses declare this if they want sources (filenames) pulled from their package names
       subclass_directive :use_package_name_for_source
+      # keeps package_names_for_targets and versions_for_targets indexed the same as package_name at
+      # the cost of having the subclass needing to deal with nils
+      subclass_directive :allow_nils
 
       #
       # Hook that subclasses use to populate the candidate_version(s)
@@ -56,7 +59,7 @@ class Chef
       def check_resource_semantics!
         # FIXME: this is not universally true and subclasses are needing to override this and no-ops it.  It should be turned into
         # another "subclass_directive" and the apt and yum providers should declare that they need this behavior.
-        if new_resource.package_name.is_a?(Array) && new_resource.source != nil
+        if new_resource.package_name.is_a?(Array) && !new_resource.source.nil?
           raise Chef::Exceptions::InvalidResourceSpecification, "You may not specify both multipackage and source"
         end
       end
@@ -196,7 +199,7 @@ class Chef
       end
 
       action :reconfig do
-        if @current_resource.version == nil
+        if @current_resource.version.nil?
           Chef::Log.debug("#{@new_resource} is NOT installed - nothing to do")
           return
         end
@@ -390,9 +393,12 @@ class Chef
       def package_names_for_targets
         package_names_for_targets = []
         target_version_array.each_with_index do |target_version, i|
-          next if target_version.nil?
-          package_name = package_name_array[i]
-          package_names_for_targets.push(package_name)
+          if !target_version.nil?
+            package_name = package_name_array[i]
+            package_names_for_targets.push(package_name)
+          else
+            package_names_for_targets.push(nil) if allow_nils?
+          end
         end
         multipackage? ? package_names_for_targets : package_names_for_targets[0]
       end
@@ -407,8 +413,11 @@ class Chef
       def versions_for_targets
         versions_for_targets = []
         target_version_array.each_with_index do |target_version, i|
-          next if target_version.nil?
-          versions_for_targets.push(target_version)
+          if !target_version.nil?
+            versions_for_targets.push(target_version)
+          else
+            versions_for_targets.push(nil) if allow_nils?
+          end
         end
         multipackage? ? versions_for_targets : versions_for_targets[0]
       end

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

@@ -169,7 +169,7 @@ EOS
         # @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))
+          shell_out_with_timeout!(args_to_string(choco_exe, *args), { :returns => new_resource.returns })
         end
 
         # Use the available_packages Hash helper to create an array suitable for
@@ -236,6 +236,7 @@ EOS
                 available[name] = desired_name_versions[name] || raw[name]
               end
             end
+          @available_packages
         end
 
         # Installed packages in chocolatey as a Hash of names mapped to versions
@@ -244,6 +245,7 @@ EOS
         # @return [Hash] name-to-version mapping of installed packages
         def installed_packages
           @installed_packages ||= Hash[*parse_list_output("list -l -r").flatten]
+          @installed_packages
         end
 
         # Helper to convert choco.exe list output to a Hash

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

@@ -0,0 +1,183 @@
+#
+# Copyright:: Copyright 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/dnf_package"
+require "chef/mixin/which"
+require "chef/mixin/get_source_from_package"
+require "chef/provider/package/dnf/python_helper"
+require "chef/provider/package/dnf/version"
+
+class Chef
+  class Provider
+    class Package
+      class Dnf < Chef::Provider::Package
+        extend Chef::Mixin::Which
+        include Chef::Mixin::GetSourceFromPackage
+
+        allow_nils
+        use_multipackage_api
+        use_package_name_for_source
+
+        provides :package, platform_family: %w{rhel fedora} do
+          which("dnf")
+        end
+
+        provides :dnf_package, os: "linux"
+
+        #
+        # Most of the magic in this class happens in the python helper script.  The ruby side of this
+        # provider knows only enough to translate Chef-style new_resource name+package+version into
+        # a request to the python side.  The python side is then responsible for knowing everything
+        # about RPMs and what is installed and what is available.  The ruby side of this class should
+        # remain a lightweight translation layer to translate Chef requests into RPC requests to
+        # python.  This class knows nothing about how to compare RPM versions, and does not maintain
+        # any cached state of installed/available versions and should be kept that way.
+        #
+        def python_helper
+          @python_helper ||= PythonHelper.instance
+        end
+
+        def load_current_resource
+          flushcache if new_resource.flush_cache[:before]
+
+          @current_resource = Chef::Resource::DnfPackage.new(new_resource.name)
+          current_resource.package_name(new_resource.package_name)
+          current_resource.version(get_current_versions)
+
+          current_resource
+        end
+
+        def define_resource_requirements
+          requirements.assert(:install, :upgrade, :remove, :purge) do |a|
+            a.assertion { !new_resource.source || ::File.exist?(new_resource.source) }
+            a.failure_message Chef::Exceptions::Package, "Package #{new_resource.package_name} not found: #{new_resource.source}"
+            a.whyrun "assuming #{new_resource.source} would have previously been created"
+          end
+
+          super
+        end
+
+        def candidate_version
+          package_name_array.each_with_index.map do |pkg, i|
+            available_version(i).version_with_arch
+          end
+        end
+
+        def get_current_versions
+          package_name_array.each_with_index.map do |pkg, i|
+            installed_version(i).version_with_arch
+          end
+        end
+
+        def install_package(names, versions)
+          if new_resource.source
+            dnf(new_resource.options, "-y install", new_resource.source)
+          else
+            resolved_names = names.each_with_index.map { |name, i| available_version(i).to_s unless name.nil? }
+            dnf(new_resource.options, "-y install", resolved_names)
+          end
+          flushcache
+        end
+
+        # dnf upgrade does not work on uninstalled packaged, while install will upgrade
+        alias_method :upgrade_package, :install_package
+
+        def remove_package(names, versions)
+          resolved_names = names.each_with_index.map { |name, i| installed_version(i).to_s unless name.nil? }
+          dnf(new_resource.options, "-y remove", resolved_names)
+          flushcache
+        end
+
+        alias_method :purge_package, :remove_package
+
+        action :flush_cache do
+          flushcache
+        end
+
+        private
+
+        def resolve_source_to_version_obj
+          shell_out_with_timeout!("rpm -qp --queryformat '%{NAME} %{EPOCH} %{VERSION} %{RELEASE} %{ARCH}\n' #{new_resource.source}").stdout.each_line do |line|
+            # this is another case of committing the sin of doing some lightweight mangling of RPM versions in ruby -- but the output of the rpm command
+            # does not match what the dnf library accepts.
+            case line
+            when /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)$/
+              return Version.new($1, "#{$2 == "(none)" ? "0" : $2}:#{$3}-#{$4}", $5)
+            end
+          end
+        end
+
+        # @returns Array<Version>
+        def available_version(index)
+          @available_version ||= []
+
+          if new_resource.source
+            @available_version[index] ||= resolve_source_to_version_obj
+          else
+            @available_version[index] ||= python_helper.query(:whatavailable, package_name_array[index], safe_version_array[index], safe_arch_array[index])
+          end
+
+          @available_version[index]
+        end
+
+        # @returns Array<Version>
+        def installed_version(index)
+          @installed_version ||= []
+          if new_resource.source
+            @installed_version[index] ||= python_helper.query(:whatinstalled, available_version(index).name, safe_version_array[index], safe_arch_array[index])
+          else
+            @installed_version[index] ||= python_helper.query(:whatinstalled, package_name_array[index], safe_version_array[index], safe_arch_array[index])
+          end
+          @installed_version[index]
+        end
+
+        # cache flushing is accomplished by simply restarting the python helper.  this produces a roughly
+        # 15% hit to the runtime of installing/removing/upgrading packages.  correctly using multipackage
+        # array installs (and the multipackage cookbook) can produce 600% improvements in runtime.
+        def flushcache
+          python_helper.restart
+        end
+
+        def dnf(*args)
+          shell_out_with_timeout!(a_to_s("dnf", *args))
+        end
+
+        def safe_version_array
+          if new_resource.version.is_a?(Array)
+            new_resource.version
+          elsif new_resource.version.nil?
+            package_name_array.map { nil }
+          else
+            [ new_resource.version ]
+          end
+        end
+
+        def safe_arch_array
+          if new_resource.arch.is_a?(Array)
+            new_resource.arch
+          elsif new_resource.arch.nil?
+            package_name_array.map { nil }
+          else
+            [ new_resource.arch ]
+          end
+        end
+
+      end
+    end
+  end
+end