chef 12.0.1 → 12.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e11671748225ec17a9c6a23041fa3cff028f640c
-  data.tar.gz: 54f0f6d8d85c7cebadf90892e102bc36caa6a420
+  metadata.gz: e516e23b8f432618bba6ae817b113bef6f1fd7e6
+  data.tar.gz: 0130eaec499c6059291f3d395b1fb282a203d9d5
 SHA512:
-  metadata.gz: 23faed269443bad8321dd3214a33f610c41a5853d541a2d93fa5cbdda8d51ff6d79f6fa6d6e934a881bf50d8c7303915b7f53a8757a2b3f4f43b933a7b0001a8
-  data.tar.gz: 15c8402828acf3b4080226341fabaa90d2dcc10dd44c4a47939e8a8e36b9e8eb257276caa7eabf29f9df7d1acfa2ab9f2338ad028d494f944958f31beb69f85c
+  metadata.gz: dad78645f06fa14308a32787553f371b741d3195df67b027afddb3f6e3e3a44b291a47bda4fddb7a623358c3677c95b145203e5657e133116cc0ee255c168b90
+  data.tar.gz: 4aa354a66a468b4100723a4027b1ff9265cfcf8c8377d3698f279c6852494c9f01bc246868c29dea3d8b49251a0c287920671bb9fbeb913bbbf0682e6a4a6ad9

data/lib/chef/chef_fs/file_system/chef_repository_file_system_entry.rb

@@ -64,7 +64,7 @@ class Chef
         end
 
         def minimize(file_contents, entry)
-          object = Chef::JSONCompat.from_json(file_contents)
+          object = Chef::JSONCompat.parse(file_contents)
           object = data_handler.normalize(object, entry)
           object = data_handler.minimize(object, entry)
           Chef::JSONCompat.to_json_pretty(object)

data/lib/chef/digester.rb

@@ -19,6 +19,7 @@
 #
 
 require 'openssl'
+require 'singleton'
 
 class Chef
   class Digester

data/lib/chef/dsl/recipe.rb

@@ -81,7 +81,7 @@ class Chef
 
         resource = build_resource(type, name, created_at, &resource_attrs_block)
 
-        run_context.resource_collection.insert(resource, resource_type:type, instance_name:name)
+        run_context.resource_collection.insert(resource, resource_type: type, instance_name: name)
         resource
       end
 
@@ -101,6 +101,7 @@ class Chef
 
         resource = resource_class.new(name, run_context)
         resource.source_line = created_at
+        resource.declared_type = type
         # If we have a resource like this one, we want to steal its state
         # This behavior is very counter-intuitive and should be removed.
         # See CHEF-3694, https://tickets.opscode.com/browse/CHEF-3694

data/lib/chef/exceptions.rb

@@ -149,6 +149,11 @@ class Chef
     class IllegalVersionConstraint < NotImplementedError; end
 
     class MetadataNotValid < StandardError; end
+    class MetadataNotFound < StandardError
+      def initialize
+        super "No metadata.rb or metadata.json!"
+      end
+    end
 
     # File operation attempted but no permissions to perform it
     class InsufficientPermissions < RuntimeError; end

data/lib/chef/knife.rb

@@ -428,6 +428,13 @@ class Chef
         raise # make sure exit passes through.
       when Net::HTTPServerException, Net::HTTPFatalError
         humanize_http_exception(e)
+      when OpenSSL::SSL::SSLError
+        ui.error "Could not establish a secure connection to the server."
+        ui.info "Use `knife ssl check` to troubleshoot your SSL configuration."
+        ui.info "If your Chef Server uses a self-signed certificate, you can use"
+        ui.info "`knife ssl fetch` to make knife trust the server's certificates."
+        ui.info ""
+        ui.info  "Original Exception: #{e.class.name}: #{e.message}"
       when Errno::ECONNREFUSED, Timeout::Error, Errno::ETIMEDOUT, SocketError
         ui.error "Network Error: #{e.message}"
         ui.info "Check your knife configuration and network settings"

data/lib/chef/knife/cookbook_site_install.rb

@@ -17,11 +17,11 @@
 #
 
 require 'chef/knife'
+require 'chef/exceptions'
 require 'shellwords'
 
 class Chef
   class Knife
-
     class CookbookSiteInstall < Knife
 
       deps do
@@ -107,11 +107,8 @@ class Chef
           end
         end
 
-
         unless config[:no_deps]
-          md = Chef::Cookbook::Metadata.new
-          md.from_file(File.join(@install_path, @cookbook_name, "metadata.rb"))
-          md.dependencies.each do |cookbook, version_list|
+          preferred_metadata.dependencies.each do |cookbook, version_list|
             # Doesn't do versions.. yet
             nv = self.class.new
             nv.config = config
@@ -144,6 +141,7 @@ class Chef
 
       def extract_cookbook(upstream_file, version)
         ui.info("Uncompressing #{@cookbook_name} version #{version}.")
+        # FIXME: Detect if we have the bad tar from git on Windows: https://github.com/opscode/chef/issues/1753
         shell_out!("tar zxvf #{convert_path upstream_file}", :cwd => @install_path)
       end
 
@@ -153,11 +151,37 @@ class Chef
       end
 
       def convert_path(upstream_file)
-      	if ENV['MSYSTEM'] == 'MINGW32'
-      	  return upstream_file.sub(/^([[:alpha:]]):/, '/\1')
-	      else
-      	  return Shellwords.escape upstream_file
-      	end
+        # converts a Windows path (C:\foo) to a mingw path (/c/foo)
+        if ENV['MSYSTEM'] == 'MINGW32'
+          return upstream_file.sub(/^([[:alpha:]]):/, '/\1')
+        else
+          return Shellwords.escape upstream_file
+        end
+      end
+
+      # Get the preferred metadata path on disk. Chef prefers the metadata.rb
+      # over the metadata.json.
+      #
+      # @raise if there is no metadata in the cookbook
+      #
+      # @return [Chef::Cookbook::Metadata]
+      def preferred_metadata
+        md = Chef::Cookbook::Metadata.new
+
+        rb   = File.join(@install_path, @cookbook_name, "metadata.rb")
+        if File.exist?(rb)
+          md.from_file(rb)
+          return md
+        end
+
+        json = File.join(@install_path, @cookbook_name, "metadata.json")
+        if File.exist?(json)
+          json = IO.read(json)
+          md.from_json(json)
+          return md
+        end
+
+        raise Chef::Exceptions::MetadataNotFound
       end
     end
   end

data/lib/chef/provider/link.rb

@@ -86,7 +86,7 @@ class Chef
       end
 
       def canonicalize(path)
-        Chef::Util::PathHelper.canonical_path(path)
+        Chef::Platform.windows? ? path.gsub('/', '\\') : path
       end
 
       def action_create

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

@@ -46,8 +46,8 @@ class Chef
         end
 
         def default_release_options
-          # Use apt::Default-Release option only if provider was explicitly defined
-          "-o APT::Default-Release=#{@new_resource.default_release}" if @new_resource.provider && @new_resource.default_release
+          # Use apt::Default-Release option only if provider supports it
+          "-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)

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

@@ -26,7 +26,8 @@ class Chef
     class Package
       class Homebrew < Chef::Provider::Package
 
-        provides :homebrew_package, os: "mac_os_x"
+        provides :homebrew_package
+        provides :package, os: ["mac_os_x", "darwin"]
 
         include Chef::Mixin::HomebrewUser
 
@@ -94,7 +95,15 @@ class Chef
         # that brew thinks is linked as the current version.
         #
         def current_installed_version
-          brew_info['keg_only'] ? brew_info['installed'].last['version'] : brew_info['linked_keg']
+          if brew_info['keg_only']
+            if brew_info['installed'].empty?
+              nil
+            else
+              brew_info['installed'].last['version']
+            end
+          else
+            brew_info['linked_keg']
+          end
         end
 
         # Packages (formula) available to install should have a

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

@@ -19,6 +19,7 @@
 # TODO: Allow @new_resource.source to be a Product Code as a GUID for uninstall / network install
 
 require 'chef/win32/api/installer' if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+require 'chef/mixin/shell_out'
 
 class Chef
   class Provider
@@ -26,6 +27,7 @@ class Chef
       class Windows
         class MSI
           include Chef::ReservedNames::Win32::API::Installer if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+          include Chef::Mixin::ShellOut
 
           def initialize(resource)
             @new_resource = resource

data/lib/chef/provider/subversion.rb

@@ -62,7 +62,7 @@ class Chef
       def action_checkout
         if target_dir_non_existent_or_empty?
           converge_by("perform checkout of #{@new_resource.repository} into #{@new_resource.destination}") do
-            shell_out!(run_options(command: checkout_command))
+            shell_out!(checkout_command, run_options)
           end
         else
           Chef::Log.debug "#{@new_resource} checkout destination #{@new_resource.destination} already exists or is a non-empty directory - nothing to do"
@@ -79,7 +79,7 @@ class Chef
 
       def action_force_export
         converge_by("export #{@new_resource.repository} into #{@new_resource.destination}") do
-          shell_out!(run_options(command: export_command))
+          shell_out!(export_command, run_options)
         end
       end
 
@@ -90,7 +90,7 @@ class Chef
           Chef::Log.debug "#{@new_resource} current revision: #{current_rev} target revision: #{revision_int}"
           unless current_revision_matches_target_revision?
             converge_by("sync #{@new_resource.destination} from #{@new_resource.repository}") do
-              shell_out!(run_options(command: sync_command))
+              shell_out!(sync_command, run_options)
               Chef::Log.info "#{@new_resource} updated to revision: #{revision_int}"
             end
           end

data/lib/chef/resource.rb

@@ -29,99 +29,14 @@ require 'chef/resource/conditional_action_not_nothing'
 require 'chef/resource_collection'
 require 'chef/node_map'
 require 'chef/node'
-require 'chef/provider_resolver'
 require 'chef/platform'
+require 'chef/resource/resource_notification'
 
 require 'chef/mixin/deprecation'
 require 'chef/mixin/descendants_tracker'
 
 class Chef
   class Resource
-    class Notification < Struct.new(:resource, :action, :notifying_resource)
-
-      def duplicates?(other_notification)
-        unless other_notification.respond_to?(:resource) && other_notification.respond_to?(:action)
-          msg = "only duck-types of Chef::Resource::Notification can be checked for duplication "\
-                "you gave #{other_notification.inspect}"
-          raise ArgumentError, msg
-        end
-        other_notification.resource == resource && other_notification.action == action
-      end
-
-      # If resource and/or notifying_resource is not a resource object, this will look them up in the resource collection
-      # and fix the references from strings to actual Resource objects.
-      def resolve_resource_reference(resource_collection)
-        return resource if resource.kind_of?(Chef::Resource) && notifying_resource.kind_of?(Chef::Resource)
-
-        if not(resource.kind_of?(Chef::Resource))
-          fix_resource_reference(resource_collection)
-        end
-
-        if not(notifying_resource.kind_of?(Chef::Resource))
-          fix_notifier_reference(resource_collection)
-        end
-      end
-
-      # This will look up the resource if it is not a Resource Object.  It will complain if it finds multiple
-      # resources, can't find a resource, or gets invalid syntax.
-      def fix_resource_reference(resource_collection)
-        matching_resource = resource_collection.find(resource)
-        if Array(matching_resource).size > 1
-          msg = "Notification #{self} from #{notifying_resource} was created with a reference to multiple resources, "\
-          "but can only notify one resource. Notifying resource was defined on #{notifying_resource.source_line}"
-          raise Chef::Exceptions::InvalidResourceReference, msg
-        end
-        self.resource = matching_resource
-
-      rescue Chef::Exceptions::ResourceNotFound => e
-        err = Chef::Exceptions::ResourceNotFound.new(<<-FAIL)
-resource #{notifying_resource} is configured to notify resource #{resource} with action #{action}, \
-but #{resource} cannot be found in the resource collection. #{notifying_resource} is defined in \
-#{notifying_resource.source_line}
-FAIL
-        err.set_backtrace(e.backtrace)
-        raise err
-      rescue Chef::Exceptions::InvalidResourceSpecification => e
-          err = Chef::Exceptions::InvalidResourceSpecification.new(<<-F)
-Resource #{notifying_resource} is configured to notify resource #{resource} with action #{action}, \
-but #{resource.inspect} is not valid syntax to look up a resource in the resource collection. Notification \
-is defined near #{notifying_resource.source_line}
-F
-          err.set_backtrace(e.backtrace)
-        raise err
-      end
-
-      # This will look up the notifying_resource if it is not a Resource Object.  It will complain if it finds multiple
-      # resources, can't find a resource, or gets invalid syntax.
-      def fix_notifier_reference(resource_collection)
-        matching_notifier = resource_collection.find(notifying_resource)
-        if Array(matching_notifier).size > 1
-          msg = "Notification #{self} from #{notifying_resource} was created with a reference to multiple notifying "\
-          "resources, but can only originate from one resource.  Destination resource was defined "\
-          "on #{resource.source_line}"
-          raise Chef::Exceptions::InvalidResourceReference, msg
-        end
-        self.notifying_resource = matching_notifier
-
-      rescue Chef::Exceptions::ResourceNotFound => e
-        err = Chef::Exceptions::ResourceNotFound.new(<<-FAIL)
-Resource #{resource} is configured to receive notifications from #{notifying_resource} with action #{action}, \
-but #{notifying_resource} cannot be found in the resource collection. #{resource} is defined in \
-#{resource.source_line}
-FAIL
-        err.set_backtrace(e.backtrace)
-        raise err
-      rescue Chef::Exceptions::InvalidResourceSpecification => e
-          err = Chef::Exceptions::InvalidResourceSpecification.new(<<-F)
-Resource #{resource} is configured to receive notifications from  #{notifying_resource} with action #{action}, \
-but #{notifying_resource.inspect} is not valid syntax to look up a resource in the resource collection. Notification \
-is defined near #{resource.source_line}
-F
-          err.set_backtrace(e.backtrace)
-        raise err
-      end
-
-    end
 
     FORBIDDEN_IVARS = [:@run_context, :@not_if, :@only_if, :@enclosing_provider]
     HIDDEN_IVARS = [:@allowed_actions, :@resource_name, :@source_line, :@run_context, :@name, :@not_if, :@only_if, :@elapsed_time, :@enclosing_provider]
@@ -212,6 +127,7 @@ F
     attr_accessor :source_line
     attr_accessor :retries
     attr_accessor :retry_delay
+    attr_accessor :declared_type
 
     attr_reader :updated
 
@@ -299,7 +215,7 @@ F
 
     def load_prior_resource(resource_type, instance_name)
       begin
-        key = ::Chef::ResourceCollection::ResourceSet.create_key(resource_type, instance_name)
+        key = "#{resource_type}[#{instance_name}]"
         prior_resource = run_context.resource_collection.lookup(key)
         # if we get here, there is a prior resource (otherwise we'd have jumped
         # to the rescue clause).
@@ -426,11 +342,11 @@ F
     def notifies(action, resource_spec, timing=:delayed)
       # when using old-style resources(:template => "/foo.txt") style, you
       # could end up with multiple resources.
+      validate_resource_spec!(resource_spec)
+
       resources = [ resource_spec ].flatten
       resources.each do |resource|
 
-        validate_resource_spec!(resource_spec)
-
         case timing.to_s
         when 'delayed'
           notifies_delayed(action, resource)
@@ -449,8 +365,12 @@ F
     # resolve_resource_reference on each in turn, causing them to
     # resolve lazy/forward references.
     def resolve_notification_references
-      run_context.immediate_notifications(self).each { |n| n.resolve_resource_reference(run_context.resource_collection) }
-      run_context.delayed_notifications(self).each {|n| n.resolve_resource_reference(run_context.resource_collection) }
+      run_context.immediate_notifications(self).each { |n|
+        n.resolve_resource_reference(run_context.resource_collection)
+      }
+      run_context.delayed_notifications(self).each {|n|
+        n.resolve_resource_reference(run_context.resource_collection)
+      }
     end
 
     def notifies_immediately(action, resource_spec)
@@ -499,6 +419,14 @@ F
       end
     end
 
+    # We usually want to store and reference resources by their declared type and not the actual type that
+    # was looked up by the Resolver (IE, "package" becomes YumPackage class).  If we have not been provided
+    # the declared key we want to fall back on the old to_s key.
+    def declared_key
+      return to_s if declared_type.nil?
+      "#{declared_type}[#{@name}]"
+    end
+
     def to_s
       "#{@resource_name}[#{@name}]"
     end
@@ -833,3 +761,7 @@ F
     end
   end
 end
+
+# We require this at the BOTTOM of this file to avoid circular requires (it is used
+# at runtime but not load time)
+require 'chef/provider_resolver'

data/lib/chef/resource/homebrew_package.rb

@@ -25,7 +25,8 @@ class Chef
   class Resource
     class HomebrewPackage < Chef::Resource::Package
 
-      provides :homebrew_package, os: "mac_os_x"
+      provides :homebrew_package
+      provides :package, os: ["mac_os_x", "darwin"]
 
       def initialize(name, run_context=nil)
         super

data/lib/chef/resource/resource_notification.rb

@@ -0,0 +1,109 @@
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright (c) 2014 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/resource'
+
+class Chef
+  class Resource
+    class Notification < Struct.new(:resource, :action, :notifying_resource)
+
+      def duplicates?(other_notification)
+        unless other_notification.respond_to?(:resource) && other_notification.respond_to?(:action)
+          msg = "only duck-types of Chef::Resource::Notification can be checked for duplication "\
+                "you gave #{other_notification.inspect}"
+          raise ArgumentError, msg
+        end
+        other_notification.resource == resource && other_notification.action == action
+      end
+
+      # If resource and/or notifying_resource is not a resource object, this will look them up in the resource collection
+      # and fix the references from strings to actual Resource objects.
+      def resolve_resource_reference(resource_collection)
+        return resource if resource.kind_of?(Chef::Resource) && notifying_resource.kind_of?(Chef::Resource)
+
+        if not(resource.kind_of?(Chef::Resource))
+          fix_resource_reference(resource_collection)
+        end
+
+        if not(notifying_resource.kind_of?(Chef::Resource))
+          fix_notifier_reference(resource_collection)
+        end
+      end
+
+      # This will look up the resource if it is not a Resource Object.  It will complain if it finds multiple
+      # resources, can't find a resource, or gets invalid syntax.
+      def fix_resource_reference(resource_collection)
+        matching_resource = resource_collection.find(resource)
+        if Array(matching_resource).size > 1
+          msg = "Notification #{self} from #{notifying_resource} was created with a reference to multiple resources, "\
+          "but can only notify one resource. Notifying resource was defined on #{notifying_resource.source_line}"
+          raise Chef::Exceptions::InvalidResourceReference, msg
+        end
+        self.resource = matching_resource
+
+      rescue Chef::Exceptions::ResourceNotFound => e
+        err = Chef::Exceptions::ResourceNotFound.new(<<-FAIL)
+resource #{notifying_resource} is configured to notify resource #{resource} with action #{action}, \
+but #{resource} cannot be found in the resource collection. #{notifying_resource} is defined in \
+#{notifying_resource.source_line}
+        FAIL
+        err.set_backtrace(e.backtrace)
+        raise err
+      rescue Chef::Exceptions::InvalidResourceSpecification => e
+        err = Chef::Exceptions::InvalidResourceSpecification.new(<<-F)
+Resource #{notifying_resource} is configured to notify resource #{resource} with action #{action}, \
+but #{resource.inspect} is not valid syntax to look up a resource in the resource collection. Notification \
+is defined near #{notifying_resource.source_line}
+        F
+        err.set_backtrace(e.backtrace)
+        raise err
+      end
+
+      # This will look up the notifying_resource if it is not a Resource Object.  It will complain if it finds multiple
+      # resources, can't find a resource, or gets invalid syntax.
+      def fix_notifier_reference(resource_collection)
+        matching_notifier = resource_collection.find(notifying_resource)
+        if Array(matching_notifier).size > 1
+          msg = "Notification #{self} from #{notifying_resource} was created with a reference to multiple notifying "\
+          "resources, but can only originate from one resource.  Destination resource was defined "\
+          "on #{resource.source_line}"
+          raise Chef::Exceptions::InvalidResourceReference, msg
+        end
+        self.notifying_resource = matching_notifier
+
+      rescue Chef::Exceptions::ResourceNotFound => e
+        err = Chef::Exceptions::ResourceNotFound.new(<<-FAIL)
+Resource #{resource} is configured to receive notifications from #{notifying_resource} with action #{action}, \
+but #{notifying_resource} cannot be found in the resource collection. #{resource} is defined in \
+#{resource.source_line}
+        FAIL
+        err.set_backtrace(e.backtrace)
+        raise err
+      rescue Chef::Exceptions::InvalidResourceSpecification => e
+        err = Chef::Exceptions::InvalidResourceSpecification.new(<<-F)
+Resource #{resource} is configured to receive notifications from  #{notifying_resource} with action #{action}, \
+but #{notifying_resource.inspect} is not valid syntax to look up a resource in the resource collection. Notification \
+is defined near #{resource.source_line}
+        F
+        err.set_backtrace(e.backtrace)
+        raise err
+      end
+
+    end
+  end
+end