chef 10.34.6 → 11.0.0.beta.0

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

@@ -58,19 +58,14 @@ class Chef
 
         def parse_emerge(package, txt)
           availables = {}
+          package_without_category = package.split("/").last
           found_package_name = nil
 
           txt.each_line do |line|
             if line =~ /\*\s+#{PACKAGE_NAME_PATTERN}/
-              found_package_name = $&.gsub(/\*/, '').strip
-              if package =~ /\// #the category is specified
-                if found_package_name == package
-                  availables[found_package_name] = nil
-                end
-              else #the category is not specified
-                if found_package_name.split("/").last == package
-                  availables[found_package_name] = nil
-                end
+              found_package_name = $&.strip
+              if found_package_name == package || found_package_name.split("/").last == package_without_category
+                availables[found_package_name] = nil
               end
             end
 

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

@@ -60,7 +60,7 @@ class Chef
             status = popen4("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@new_resource.source}") do |pid, stdin, stdout, stderr|
               stdout.each do |line|
                 case line
-                when /^([\w\d_.-]+)\s([\w\d_.-]+)$/
+                when /([\w\d_.-]+)\s([\w\d_.-]+)/
                   @current_resource.package_name($1)
                   @new_resource.version($2)
                 end
@@ -77,7 +77,7 @@ class Chef
           @rpm_status = popen4("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@current_resource.package_name}") do |pid, stdin, stdout, stderr|
             stdout.each do |line|
               case line
-              when /^([\w\d_.-]+)\s([\w\d_.-]+)$/
+              when /([\w\d_.-]+)\s([\w\d_.-]+)/
                 Chef::Log.debug("#{@new_resource} current version is #{$2}")
                 @current_resource.version($2)
               end

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

@@ -31,14 +31,7 @@ require 'rubygems/version'
 require 'rubygems/dependency'
 require 'rubygems/spec_fetcher'
 require 'rubygems/platform'
-
-# Compatibility note: Rubygems 2.0 removes rubygems/format in favor of
-# rubygems/package.
-begin
-  require 'rubygems/format'
-rescue LoadError
-  require 'rubygems/package'
-end
+require 'rubygems/format'
 require 'rubygems/dependency_installer'
 require 'rubygems/uninstaller'
 require 'rubygems/specification'
@@ -112,22 +105,6 @@ class Chef
             Gem.sources = original_sources
           end
 
-          ##
-          # Extracts the gemspec from a (on-disk) gem package.
-          # === Returns
-          # Gem::Specification
-          #
-          #--
-          # Compatibility note: Rubygems 1.x uses Gem::Format, 2.0 moved this
-          # code into Gem::Package.
-          def spec_from_file(file)
-            if defined?(Gem::Format) and Gem::Package.respond_to?(:open)
-              Gem::Format.from_file_by_path(file).spec
-            else
-              Gem::Package.new(file).spec
-            end
-          end
-
           ##
           # Determines the candidate version for a gem from a .gem file on disk
           # and checks if it matches the version contraints in +gem_dependency+
@@ -137,7 +114,7 @@ class Chef
           # nil           returns nil if the gem on disk doesn't match the
           #               version constraints for +gem_dependency+
           def candidate_version_from_file(gem_dependency, source)
-            spec = spec_from_file(source)
+            spec = Gem::Format.from_file_by_path(source).spec
             if spec.satisfies_requirement?(gem_dependency)
               logger.debug {"#{@new_resource} found candidate gem version #{spec.version} from local gem package #{source}"}
               spec.version
@@ -165,26 +142,17 @@ class Chef
           # Find the newest gem version available from Gem.sources that satisfies
           # the constraints of +gem_dependency+
           def find_newest_remote_version(gem_dependency, *sources)
-            available_gems = dependency_installer.find_gems_with_sources(gem_dependency)
-            spec, source = if available_gems.respond_to?(:last)
-              # DependencyInstaller sorts the results such that the last one is
-              # always the one it considers best.
-              spec_with_source = available_gems.last
-              spec_with_source && spec_with_source
-            else
-              # Rubygems 2.0 returns a Gem::Available set, which is a
-              # collection of AvailableSet::Tuple structs
-              available_gems.pick_best!
-              best_gem = available_gems.set.first
-              best_gem && [best_gem.spec, best_gem.source]
-            end
+            # DependencyInstaller sorts the results such that the last one is
+            # always the one it considers best.
+            spec_with_source = dependency_installer.find_gems_with_sources(gem_dependency).last
 
-            version = spec && spec.version
+            spec = spec_with_source && spec_with_source[0]
+            version = spec && spec_with_source[0].version
             if version
-              logger.debug { "#{@new_resource} found gem #{spec.name} version #{version} for platform #{spec.platform} from #{source}" }
+              logger.debug { "#{@new_resource} found gem #{spec.name} version #{version} for platform #{spec.platform} from #{spec_with_source[1]}" }
               version
             else
-              source_list = sources.compact.empty? ? "[#{Gem.sources.to_a.join(', ')}]" : "[#{sources.join(', ')}]"
+              source_list = sources.compact.empty? ? "[#{Gem.sources.join(', ')}]" : "[#{sources.join(', ')}]"
               logger.warn { "#{@new_resource} failed to find gem #{gem_dependency} from #{source_list}" }
               nil
             end

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

@@ -16,10 +16,8 @@
 # limitations under the License.
 #
 
-require 'chef/config'
 require 'chef/provider/package'
 require 'chef/mixin/command'
-require 'chef/mixin/shell_out'
 require 'chef/resource/package'
 require 'singleton'
 require 'chef/mixin/get_source_from_package'
@@ -647,7 +645,6 @@ class Chef
         # Cache for our installed and available packages, pulled in from yum-dump.py
         class YumCache
           include Chef::Mixin::Command
-          include Chef::Mixin::ShellOut
           include Singleton
 
           def initialize
@@ -708,11 +705,9 @@ class Chef
             error = nil
 
             helper = ::File.join(::File.dirname(__FILE__), 'yum-dump.py')
-            status = nil
 
-            begin
-              status = shell_out!("/usr/bin/python #{helper}#{opts}", :timeout => Chef::Config[:yum_timeout])
-              status.stdout.each_line do |line|
+            status = popen4("/usr/bin/python #{helper}#{opts}", :waitlast => true) do |pid, stdin, stdout, stderr|
+              stdout.each do |line|
                 one_line = true
 
                 line.chomp!
@@ -759,10 +754,7 @@ class Chef
                 @rpmdb << pkg
               end
 
-              error = status.stderr
-            rescue Mixlib::ShellOut::CommandTimeout => e
-              Chef::Log.error("#{helper} exceeded timeout #{Chef::Config[:yum_timeout]}")
-              raise(e)
+              error = stderr.readlines
             end
 
             if status.exitstatus != 0
@@ -947,7 +939,6 @@ class Chef
         end # YumCache
 
         include Chef::Mixin::GetSourceFromPackage
-        include Chef::Mixin::ShellOut
 
         def initialize(new_resource, run_context)
           super
@@ -990,7 +981,7 @@ class Chef
         end
 
         def yum_command(command)
-          status, stdout, stderr = output_of_command(command, {:timeout => Chef::Config[:yum_timeout]})
+          status, stdout, stderr = output_of_command(command, {})
 
           # This is fun: rpm can encounter errors in the %post/%postun scripts which aren't
           # considered fatal - meaning the rpm is still successfully installed. These issue
@@ -1007,7 +998,7 @@ class Chef
               if l =~ %r{^error: %(post|postun)\(.*\) scriptlet failed, exit status \d+$}
                 Chef::Log.warn("#{@new_resource} caught non-fatal scriptlet issue: \"#{l}\". Can't trust yum exit status " +
                                "so running install again to verify.")
-                status, stdout, stderr = output_of_command(command, {:timeout => Chef::Config[:yum_timeout]})
+                status, stdout, stderr = output_of_command(command, {})
                 break
               end
             end
@@ -1071,11 +1062,13 @@ class Chef
             end
 
             Chef::Log.debug("#{@new_resource} checking rpm status")
-            shell_out!("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@new_resource.source}", :timeout => Chef::Config[:yum_timeout]).stdout.each_line do |line|
-              case line
-              when /([\w\d_.-]+)\s([\w\d_.-]+)/
-                @current_resource.package_name($1)
-                @new_resource.version($2)
+            status = popen4("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' #{@new_resource.source}") do |pid, stdin, stdout, stderr|
+              stdout.each do |line|
+                case line
+                when /([\w\d_.-]+)\s([\w\d_.-]+)/
+                  @current_resource.package_name($1)
+                  @new_resource.version($2)
+                end
               end
             end
           end

data/lib/chef/provider/registry_key.rb

@@ -0,0 +1,156 @@
+#
+# Author:: Prajakta Purohit (<prajakta@opscode.com>)
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+#
+# Copyright:: 2011, Opscode, Inc.
+#
+# 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/config'
+require 'chef/log'
+require 'chef/resource/file'
+require 'chef/mixin/checksum'
+require 'chef/provider'
+require 'etc'
+require 'fileutils'
+require 'chef/scan_access_control'
+require 'chef/mixin/shell_out'
+require 'chef/win32/registry'
+
+class Chef
+
+  class Provider
+    class RegistryKey < Chef::Provider
+      include Chef::Mixin::Checksum
+      include Chef::Mixin::ShellOut
+
+      def whyrun_supported?
+        true
+      end
+
+      def running_on_windows!
+        unless Chef::Platform.windows?
+          raise Chef::Exceptions::Win32NotWindows, "Attempt to manipulate the windows registry on a non-windows node"
+        end
+      end
+
+      def load_current_resource
+        running_on_windows!
+        @current_resource ||= Chef::Resource::RegistryKey.new(@new_resource.key, run_context)
+        @current_resource.key(@new_resource.key)
+        @current_resource.architecture(@new_resource.architecture)
+        @current_resource.recursive(@new_resource.recursive)
+        if registry.key_exists?(@new_resource.key)
+          @current_resource.values(registry.get_values(@new_resource.key))
+        end
+        values_to_hash(@current_resource.values)
+        @current_resource
+      end
+
+      def registry
+        @registry ||= Chef::Win32::Registry.new(@run_context, @new_resource.architecture)
+      end
+
+     def values_to_hash(values)
+        if values
+         @name_hash = Hash[values.map { |val| [val[:name], val] }]
+        else
+          @name_hash = {}
+        end
+      end
+
+      def define_resource_requirements
+        requirements.assert(:create, :create_if_missing, :delete, :delete_key) do |a|
+          a.assertion{ registry.hive_exists?(@new_resource.key) }
+          a.failure_message(Chef::Exceptions::Win32RegHiveMissing, "Hive #{@new_resource.key.split("\\").shift} does not exist")
+        end
+        requirements.assert(:create) do |a|
+          a.assertion{ registry.key_exists?(@new_resource.key) }
+          a.whyrun("Key #{@new_resource.key} does not exist. Unless it would have been created before, attempt to modify its values would fail.")
+        end
+        requirements.assert(:create, :create_if_missing) do |a|
+          #If keys missing in the path and recursive == false
+          a.assertion{ !registry.keys_missing?(@current_resource.key) || @new_resource.recursive }
+          a.failure_message(Chef::Exceptions::Win32RegNoRecursive, "Intermediate keys missing but recursive is set to false")
+          a.whyrun("Intermediate keys in #{@new_resource.key} go not exist. Unless they would have been created earlier, attempt to modify them would fail.")
+        end
+        requirements.assert(:delete_key) do |a|
+          #If key to be deleted has subkeys but recurssive == false
+          a.assertion{ !registry.key_exists?(@new_resource.key) || !registry.has_subkeys?(@new_resource.key) || @new_resource.recursive }
+          a.failure_message(Chef::Exceptions::Win32RegNoRecursive, "#{@new_resource.key} has subkeys but recursive is set to false.")
+          a.whyrun("#{@current_resource.key} has subkeys, but recursive is set to false. attempt to delete would fails unless subkeys were deleted prior to this action.")
+        end
+      end
+
+      def action_create
+        unless registry.key_exists?(@current_resource.key)
+          converge_by("create key #{@new_resource.key}") do
+            registry.create_key(@new_resource.key, @new_resource.recursive)
+          end
+        end
+        @new_resource.values.each do |value|
+          if @name_hash.has_key?(value[:name])
+            current_value = @name_hash[value[:name]]
+            unless current_value[:type] == value[:type] && current_value[:data] == value[:data]
+              converge_by("set value #{value}") do
+                registry.set_value(@new_resource.key, value)
+              end
+            end
+          else
+            converge_by("set value #{value}") do
+              registry.set_value(@new_resource.key, value)
+            end
+          end
+        end
+      end
+
+      def action_create_if_missing
+        unless registry.key_exists?(@new_resource.key)
+          converge_by("create key #{@new_resource.key}") do
+            registry.create_key(@new_resource.key, @new_resource.recursive)
+          end
+        end
+        @new_resource.values.each do |value|
+          unless @name_hash.has_key?(value[:name])
+            converge_by("create value #{value}") do
+              registry.set_value(@new_resource.key, value)
+            end
+          end
+        end
+      end
+
+      def action_delete
+        if registry.key_exists?(@new_resource.key)
+          @new_resource.values.each do |value|
+            if @name_hash.has_key?(value[:name])
+              converge_by("delete value #{value}") do
+                registry.delete_value(@new_resource.key, value)
+              end
+            end
+          end
+        end
+      end
+
+      def action_delete_key
+        if registry.key_exists?(@new_resource.key)
+          converge_by("delete key #{@new_resource.key}") do
+            registry.delete_key(@new_resource.key, @new_resource.recursive)
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/chef/provider/remote_directory.rb

@@ -30,6 +30,8 @@ require 'set'
 class Chef
   class Provider
     class RemoteDirectory < Chef::Provider::Directory
+
+      include Chef::Mixin::EnforceOwnershipAndPermissions
       include Chef::Mixin::FileClass
 
       def action_create

data/lib/chef/provider/remote_file.rb

@@ -26,6 +26,8 @@ class Chef
   class Provider
     class RemoteFile < Chef::Provider::File
 
+      include Chef::Mixin::EnforceOwnershipAndPermissions
+
       def load_current_resource
         @current_resource = Chef::Resource::RemoteFile.new(@new_resource.name)
         super
@@ -37,12 +39,24 @@ class Chef
         if current_resource_matches_target_checksum?
           Chef::Log.debug("#{@new_resource} checksum matches target checksum (#{@new_resource.checksum}) - not updating")
         else
-          rest = Chef::REST.new(@new_resource.source, nil, nil, http_client_opts)
-          raw_file = rest.streaming_request(rest.create_url(@new_resource.source), {})
+          sources = @new_resource.source
+          source = sources.shift
+          begin
+            rest = Chef::REST.new(source, nil, nil, http_client_opts(source))
+            raw_file = rest.streaming_request(rest.create_url(source), {})
+          rescue SocketError, Errno::ECONNREFUSED, Timeout::Error, Net::HTTPFatalError => e
+            Chef::Log.debug("#{@new_resource} cannot be downloaded from #{source}")
+            if source = sources.shift
+              Chef::Log.debug("#{@new_resource} trying to download from another mirror")
+              retry
+            else
+              raise e
+            end
+          end
           if matches_current_checksum?(raw_file)
             Chef::Log.debug "#{@new_resource} target and source checksums are the same - not updating"
           else
-            description = []
+            description = [] 
             description << "copy file downloaded from #{@new_resource.source} into #{@new_resource.path}"
             description << diff_current(raw_file.path)
             converge_by(description) do
@@ -52,13 +66,14 @@ class Chef
               raw_file.close!
             end
             # whyrun mode cleanup - the temp file will never be used,
-            # so close/unlink it here.
+            # so close/unlink it here. 
             if whyrun_mode?
               raw_file.close!
             end
           end
         end
         set_all_access_controls
+        update_new_file_state
       end
 
       def current_resource_matches_target_checksum?
@@ -97,7 +112,7 @@ class Chef
         end
       end
 
-      def http_client_opts
+      def http_client_opts(source)
         opts={}
         # CHEF-3140
         # 1. If it's already compressed, trying to compress it more will
@@ -107,7 +122,7 @@ class Chef
         # which tricks Chef::REST into decompressing the response body. In this
         # case you'd end up with a tar archive (no gzip) named, e.g., foo.tgz,
         # which is not what you wanted.
-        if @new_resource.path =~ /gz$/ or @new_resource.source =~ /gz$/
+        if @new_resource.path =~ /gz$/ or source =~ /gz$/
           opts[:disable_gzip] = true
         end
         opts
@@ -121,12 +136,6 @@ class Chef
         false
       end
 
-      def managing_content?
-        return true if @new_resource.checksum
-        return true if !@new_resource.source.nil? && @action != :create_if_missing
-        false
-      end
-
     end
   end
 end