chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/lib/chef/cookbook_loader.rb

@@ -161,7 +161,7 @@ class Chef
       @all_files_in_repo_paths ||=
         begin
           @repo_paths.inject([]) do |all_children, repo_path|
-            all_children += Dir[File.join(repo_path, "*")]
+            all_children += Dir[File.join(Chef::Util::PathHelper.escape_glob(repo_path), "*")]
           end
         end
     end

data/lib/chef/cookbook_version.rb

@@ -315,13 +315,20 @@ class Chef
       else
         if segment == :files || segment == :templates
           error_message = "Cookbook '#{name}' (#{version}) does not contain a file at any of these locations:\n"
-          error_locations = [
-            "  #{segment}/#{node[:platform]}-#{node[:platform_version]}/#{filename}",
-            "  #{segment}/#{node[:platform]}/#{filename}",
-            "  #{segment}/default/#{filename}",
-          ]
+          error_locations = if filename.is_a?(Array)
+            filename.map{|name| "  #{File.join(segment.to_s, name)}"}
+          else
+            [
+              "  #{segment}/#{node[:platform]}-#{node[:platform_version]}/#{filename}",
+              "  #{segment}/#{node[:platform]}/#{filename}",
+              "  #{segment}/default/#{filename}",
+              "  #{segment}/#{filename}",
+            ]
+          end
           error_message << error_locations.join("\n")
           existing_files = segment_filenames(segment)
+          # Strip the root_dir prefix off all files for readability
+          existing_files.map!{|path| path[root_dir.length+1..-1]} if root_dir
           # Show the files that the cookbook does have. If the user made a typo,
           # hopefully they'll see it here.
           unless existing_files.empty?
@@ -421,38 +428,44 @@ class Chef
     def preferences_for_path(node, segment, path)
       # only files and templates can be platform-specific
       if segment.to_sym == :files || segment.to_sym == :templates
-        begin
-          platform, version = Chef::Platform.find_platform_and_version(node)
-        rescue ArgumentError => e
-          # Skip platform/version if they were not found by find_platform_and_version
-          if e.message =~ /Cannot find a (?:platform|version)/
-            platform = "/unknown_platform/"
-            version = "/unknown_platform_version/"
-          else
-            raise
+        relative_search_path = if path.is_a?(Array)
+          path
+        else
+          begin
+            platform, version = Chef::Platform.find_platform_and_version(node)
+          rescue ArgumentError => e
+            # Skip platform/version if they were not found by find_platform_and_version
+            if e.message =~ /Cannot find a (?:platform|version)/
+              platform = "/unknown_platform/"
+              version = "/unknown_platform_version/"
+            else
+              raise
+            end
           end
-        end
 
-        fqdn = node[:fqdn]
+          fqdn = node[:fqdn]
 
-        # Break version into components, eg: "5.7.1" => [ "5.7.1", "5.7", "5" ]
-        search_versions = []
-        parts = version.to_s.split('.')
+          # Break version into components, eg: "5.7.1" => [ "5.7.1", "5.7", "5" ]
+          search_versions = []
+          parts = version.to_s.split('.')
 
-        parts.size.times do
-          search_versions << parts.join('.')
-          parts.pop
-        end
+          parts.size.times do
+            search_versions << parts.join('.')
+            parts.pop
+          end
 
-        # Most specific to least specific places to find the path
-        search_path = [ File.join(segment.to_s, "host-#{fqdn}", path) ]
-        search_versions.each do |v|
-          search_path << File.join(segment.to_s, "#{platform}-#{v}", path)
-        end
-        search_path << File.join(segment.to_s, platform.to_s, path)
-        search_path << File.join(segment.to_s, "default", path)
+          # Most specific to least specific places to find the path
+          search_path = [ File.join("host-#{fqdn}", path) ]
+          search_versions.each do |v|
+            search_path << File.join("#{platform}-#{v}", path)
+          end
+          search_path << File.join(platform.to_s, path)
+          search_path << File.join("default", path)
+          search_path << path
 
-        search_path
+          search_path
+        end
+        relative_search_path.map {|relative_path| File.join(segment.to_s, relative_path)}
       else
         [File.join(segment, path)]
       end
@@ -479,7 +492,7 @@ class Chef
       cookbook_version.manifest = o
 
       # We don't need the following step when we decide to stop supporting deprecated operators in the metadata (e.g. <<, >>)
-      cookbook_version.manifest["metadata"] = Chef::JSONCompat.from_json(cookbook_version.metadata.to_json)
+      cookbook_version.manifest["metadata"] = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(cookbook_version.metadata))
 
       cookbook_version.freeze_version if o["frozen?"]
       cookbook_version
@@ -552,6 +565,11 @@ class Chef
       chef_server_rest.get_rest('cookbooks')
     end
 
+    # Alias latest_cookbooks as list
+    class << self
+      alias :latest_cookbooks :list
+    end
+
     def self.list_all_versions
       chef_server_rest.get_rest('cookbooks?num_versions=all')
     end
@@ -575,11 +593,6 @@ class Chef
       end
     end
 
-    # Get the newest version of all cookbooks
-    def self.latest_cookbooks
-      chef_server_rest.get_rest('cookbooks/_latest')
-    end
-
     def <=>(o)
       raise Chef::Exceptions::CookbookVersionNameMismatch if self.name != o.name
       # FIXME: can we change the interface to the Metadata class such
@@ -660,13 +673,19 @@ class Chef
 
     def parse_segment_file_from_root_paths(segment, segment_file)
       root_paths.each do |root_path|
-        pathname = Pathname.new(segment_file).relative_path_from(Pathname.new(root_path))
+        pathname = Chef::Util::PathHelper.relative_path_from(root_path, segment_file)
 
         parts = pathname.each_filename.take(2)
         # Check if path is actually under root_path
         next if parts[0] == '..'
         if segment == :templates || segment == :files
-          return [ pathname.to_s, parts[1] ]
+          # Check if pathname looks like files/foo or templates/foo (unscoped)
+          if pathname.each_filename.to_a.length == 2
+            # Use root_default in case the same path exists at root_default and default
+            return [ pathname.to_s, 'root_default' ]
+          else
+            return [ pathname.to_s, parts[1] ]
+          end
         else
           return [ pathname.to_s, 'default' ]
         end

data/lib/chef/data_bag.rb

@@ -90,7 +90,7 @@ class Chef
             raise Chef::Exceptions::InvalidDataBagPath, "Data bag path '#{path}' is invalid"
           end
 
-          names += Dir.glob(File.join(path, "*")).map{|f|File.basename(f)}.sort
+          names += Dir.glob(File.join(Chef::Util::PathHelper.escape_glob(path), "*")).map{|f|File.basename(f)}.sort
         end
         names.inject({}) {|h, n| h[n] = n; h}
       else
@@ -116,7 +116,7 @@ class Chef
             raise Chef::Exceptions::InvalidDataBagPath, "Data bag path '#{path}' is invalid"
           end
 
-          Dir.glob(File.join(path, name.to_s, "*.json")).inject({}) do |bag, f|
+          Dir.glob(File.join(Chef::Util::PathHelper.escape_glob(path, name.to_s), "*.json")).inject({}) do |bag, f|
             item = Chef::JSONCompat.from_json(IO.read(f))
 
             # Check if we have multiple items with similar names (ids) and raise if their content differs

data/lib/chef/deprecation/provider/file.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 
+require 'chef/util/path_helper'
 
 class Chef
   module Deprecation
@@ -180,7 +181,7 @@ class Chef
 
             # Clean up after the number of backups
             slice_number = @new_resource.backup
-            backup_files = Dir[::File.join(prefix, ".#{@new_resource.path}.chef-*")].sort { |a,b| b <=> a }
+            backup_files = Dir[Chef::Util::PathHelper.escape_glob(prefix, ".#{@new_resource.path}") + ".chef-*"].sort { |a,b| b <=> a }
             if backup_files.length >= @new_resource.backup
               remainder = backup_files.slice(slice_number..-1)
               remainder.each do |backup_to_delete|

data/lib/chef/dsl/data_query.rb

@@ -20,6 +20,7 @@ require 'chef/search/query'
 require 'chef/data_bag'
 require 'chef/data_bag_item'
 require 'chef/encrypted_data_bag_item'
+require 'chef/encrypted_data_bag_item/check_encrypted'
 
 class Chef
   module DSL
@@ -28,6 +29,7 @@ class Chef
     # Provides DSL for querying data from the chef-server via search or data
     # bag.
     module DataQuery
+      include Chef::EncryptedDataBagItem::CheckEncrypted
 
       def search(*args, &block)
         # If you pass a block, or have at least the start argument, do raw result parsing
@@ -78,35 +80,6 @@ class Chef
         raise
       end
 
-      private
-
-      # Tries to autodetect if the item's raw hash appears to be encrypted.
-      def encrypted?(raw_data)
-        data = raw_data.reject { |k, _| k == "id" } # Remove the "id" key.
-        # Assume hashes containing only the "id" key are not encrypted.
-        # Otherwise, remove the keys that don't appear to be encrypted and compare
-        # the result with the hash. If some entry has been removed, then some entry
-        # doesn't appear to be encrypted and we assume the entire hash is not encrypted.
-        data.empty? ? false : data.reject { |_, v| !looks_like_encrypted?(v) } == data
-      end
-
-      # Checks if data looks like it has been encrypted by
-      # Chef::EncryptedDataBagItem::Encryptor::VersionXEncryptor. Returns
-      # true only when there is an exact match between the VersionXEncryptor
-      # keys and the hash's keys.
-      def looks_like_encrypted?(data)
-        return false unless data.is_a?(Hash) && data.has_key?("version")
-        case data["version"]
-        when 1
-          Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor.encryptor_keys.sort == data.keys.sort
-        when 2
-          Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor.encryptor_keys.sort == data.keys.sort
-        when 3
-          Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor.encryptor_keys.sort == data.keys.sort
-        else
-          false # version means something else... assume not encrypted.
-        end
-      end
     end
   end
 end

data/lib/chef/dsl/recipe.rb

@@ -17,8 +17,8 @@
 # limitations under the License.
 #
 
-require 'chef/resource_platform_map'
 require 'chef/mixin/convert_to_class_name'
+require 'chef/exceptions'
 
 class Chef
   module DSL
@@ -52,9 +52,7 @@ class Chef
       end
 
       def has_resource_definition?(name)
-        yes_or_no = run_context.definitions.has_key?(name)
-
-        yes_or_no
+        run_context.definitions.has_key?(name)
       end
 
       # Processes the arguments and block as a resource definition.
@@ -68,12 +66,10 @@ class Chef
         # This sets up the parameter overrides
         new_def.instance_eval(&block) if block
 
-
         new_recipe = Chef::Recipe.new(cookbook_name, recipe_name, run_context)
         new_recipe.params = new_def.params
         new_recipe.params[:name] = args[0]
         new_recipe.instance_eval(&new_def.recipe)
-        new_recipe
       end
 
       # Instantiates a resource (via #build_resource), then adds it to the
@@ -85,21 +81,7 @@ class Chef
 
         resource = build_resource(type, name, created_at, &resource_attrs_block)
 
-        # Some resources (freebsd_package) can be invoked with multiple names
-        # (package || freebsd_package).
-        # https://github.com/opscode/chef/issues/1773
-        # For these resources we want to make sure
-        # their key in resource collection is same as the name they are declared
-        # as. Since this might be a breaking change for resources that define
-        # customer to_s methods, we are working around the issue by letting
-        # resources know of their created_as_type until this issue is fixed in
-        # Chef 12:
-        # https://github.com/opscode/chef/issues/1817
-        if resource.respond_to?(:created_as_type=)
-          resource.created_as_type = type
-        end
-
-        run_context.resource_collection.insert(resource)
+        run_context.resource_collection.insert(resource, resource_type:type, instance_name:name)
         resource
       end
 
@@ -123,7 +105,7 @@ class Chef
         # This behavior is very counter-intuitive and should be removed.
         # See CHEF-3694, https://tickets.opscode.com/browse/CHEF-3694
         # Moved to this location to resolve CHEF-5052, https://tickets.opscode.com/browse/CHEF-5052
-        resource.load_prior_resource
+        resource.load_prior_resource(type, name)
         resource.cookbook_name = cookbook_name
         resource.recipe_name = recipe_name
         # Determine whether this resource is being created in the context of an enclosing Provider
@@ -162,6 +144,10 @@ class Chef
         end
       end
 
+      def exec(args)
+        raise Chef::Exceptions::ResourceNotFound, "exec was called, but you probably meant to use an execute resource.  If not, please call Kernel#exec explicitly.  The exec block called was \"#{args}\""
+      end
+
     end
   end
 end

data/lib/chef/encrypted_data_bag_item/assertions.rb

@@ -45,7 +45,7 @@ class Chef::EncryptedDataBagItem
 
     def assert_aead_requirements_met!(algorithm)
       unless OpenSSL::Cipher.method_defined?(:auth_data=)
-        raise EncryptedDataBagRequirementsFailure, "The used Encrypted Data Bags version requires Ruby >= 1.9"
+        raise EncryptedDataBagRequirementsFailure, "The used Encrypted Data Bags version requires Ruby >= 2.0"
       end
       unless OpenSSL::Cipher.ciphers.include?(algorithm)
         raise EncryptedDataBagRequirementsFailure, "The used Encrypted Data Bags version requires an OpenSSL version with \"#{algorithm}\" algorithm support"

data/lib/chef/encrypted_data_bag_item/check_encrypted.rb

@@ -0,0 +1,56 @@
+#
+# Author:: Tyler Ball (<tball@getchef.com>)
+# Copyright:: Copyright (c) 2010-2014 Opscode, 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/encrypted_data_bag_item/encryptor'
+
+class Chef::EncryptedDataBagItem
+  # Common code for checking if a data bag appears encrypted
+  module CheckEncrypted
+
+    # Tries to autodetect if the item's raw hash appears to be encrypted.
+    def encrypted?(raw_data)
+      data = raw_data.reject { |k, _| k == "id" } # Remove the "id" key.
+      # Assume hashes containing only the "id" key are not encrypted.
+      # Otherwise, remove the keys that don't appear to be encrypted and compare
+      # the result with the hash. If some entry has been removed, then some entry
+      # doesn't appear to be encrypted and we assume the entire hash is not encrypted.
+      data.empty? ? false : data.reject { |_, v| !looks_like_encrypted?(v) } == data
+    end
+
+    private
+
+    # Checks if data looks like it has been encrypted by
+    # Chef::EncryptedDataBagItem::Encryptor::VersionXEncryptor. Returns
+    # true only when there is an exact match between the VersionXEncryptor
+    # keys and the hash's keys.
+    def looks_like_encrypted?(data)
+      return false unless data.is_a?(Hash) && data.has_key?("version")
+      case data["version"]
+        when 1
+          Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor.encryptor_keys.sort == data.keys.sort
+        when 2
+          Chef::EncryptedDataBagItem::Encryptor::Version2Encryptor.encryptor_keys.sort == data.keys.sort
+        when 3
+          Chef::EncryptedDataBagItem::Encryptor::Version3Encryptor.encryptor_keys.sort == data.keys.sort
+        else
+          false # version means something else... assume not encrypted.
+      end
+    end
+
+  end
+end

data/lib/chef/encrypted_data_bag_item/encrypted_data_bag_item_assertions.rb

@@ -25,7 +25,7 @@ class Chef::EncryptedDataBagItem
 
     def assert_requirements_met!
       unless OpenSSL::Cipher.method_defined?(:auth_data=)
-        raise EncryptedDataBagRequirementsFailure, "The used Encrypted Data Bags version requires Ruby >= 1.9"
+        raise EncryptedDataBagRequirementsFailure, "The used Encrypted Data Bags version requires Ruby >= 2.0"
       end
       unless OpenSSL::Cipher.ciphers.include?(algorithm)
         raise EncryptedDataBagRequirementsFailure, "The used Encrypted Data Bags version requires an OpenSSL version with \"#{algorithm}\" algorithm support"

data/lib/chef/event_loggers/base.rb

@@ -0,0 +1,62 @@
+#
+# Author:: Jay Mundrawala (<jdm@getchef.com>)
+#
+# Copyright:: 2014, Chef Software, 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/event_dispatch/base'
+
+class Chef
+  module EventLoggers
+    class UnknownEventLogger < StandardError; end
+    class UnavailableEventLogger < StandardError; end
+
+    def self.event_loggers_by_name
+      @event_loggers_by_name ||= {}
+    end
+
+    def self.register(name, logger)
+      event_loggers_by_name[name.to_s] = logger
+    end
+
+    def self.by_name(name)
+      event_loggers_by_name[name]
+    end
+
+    def self.available_event_loggers
+      event_loggers_by_name.select do |key, val|
+        val.available?
+      end.keys
+    end
+
+    def self.new(name)
+      event_logger_class = by_name(name.to_s) or
+        raise UnknownEventLogger, "No event logger found for #{name} (available: #{available_event_loggers.join(', ')})"
+      raise UnavailableEventLogger unless available_event_loggers.include? name.to_s
+      event_logger_class.new
+    end
+
+    class Base < EventDispatch::Base
+      def self.short_name(name)
+        Chef::EventLoggers.register(name, self)
+      end
+
+      # Returns true if this implementation of EventLoggers can be used
+      def self.available?
+        false
+      end
+    end
+  end
+end