chef 12.0.0.alpha.0-x86-mingw32 → 12.0.0.alpha.1-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60e7ed5e2729a9e7c21acfa95d07e43638d78730
-  data.tar.gz: 3ece05335bad2e82332cd470ce29ee001ec99810
+  metadata.gz: d09796613f1004fd31743d62e30f2b6e10741d8e
+  data.tar.gz: deee29276799d1858418b4850c69d4955548468e
 SHA512:
-  metadata.gz: c71f624aacf29771b168d4d03ede5d1c1dc9eeb4e0975d1e067593d6b90725b19b162be6c834725271266a49148ad7c6e0f17a19440c3696c10624e5ea7708a5
-  data.tar.gz: 74084acfde35c719290511363cec2ff6f243a4a47b6d32c72fac162969db2466d4fbf2c5ff7be31dcd438a525443d2f12ea2f1f65b8e73c3f17a4c24f3fdde18
+  metadata.gz: 27c7d1868381141741cb793d3e6c5859b3e5ac2f0fd049be3fdbe0bbfd90d71f213a5f6563bebbfdfd80c429db40eb9d88fddfaa8717428ebb9484cf4677e729
+  data.tar.gz: f4797ef8e7782d0a8a1fcffb6d92ca316c79a77e93b498069ea8fb28fb0260867f4d3a654934228a9638520265cc101df623d59ea11a5c8c69cc3c74e00a0daf

data/CONTRIBUTING.md

@@ -11,9 +11,7 @@ We utilize **Github Issues** for issue tracking and contributions. You can contr
 
 We have a 3 step process that utilizes **Github Issues**:
 
-1. Sign our
-  [Individual Contributor License Agreement (CLA)](https://secure.echosign.com/public/hostedForm?formid=PJIF5694K6L)
-  or [Corporate CLA](https://secure.echosign.com/public/hostedForm?formid=PIE6C7AX856) online once.
+1. Sign or be added to an existing [Contributor License Agreement (CLA)](https://supermarket.getchef.com/become-a-contributor).
 2. Create a Github Pull Request.
 3. Do [Code Review](#cr) with the **Chef Engineering Team** or **Chef Core Committers** on the pull request.
 
@@ -83,10 +81,10 @@ To make a good faith effort to ensure these criteria are met, Chef requires an I
 It only takes a few minutes to complete a CLA, and you retain the copyright to your contribution.
 
 You can complete our
-  [Individual CLA](https://secure.echosign.com/public/hostedForm?formid=PJIF5694K6L) online.
+  [Individual CLA](https://supermarket.getchef.com/icla-signatures/new) online.
   If you're contributing on behalf of your employer and they retain the copyright for your works,
   have your employer fill out our
-  [Corporate CLA](https://secure.echosign.com/public/hostedForm?formid=PIE6C7AX856) instead.
+  [Corporate CLA](https://supermarket.getchef.com/ccla-signatures/new) instead.
 
 ### Chef Obvious Fix Policy
 

data/lib/chef/api_client.rb

@@ -121,7 +121,7 @@ class Chef
     #
     # @return [String] the JSON string.
     def to_json(*a)
-      to_hash.to_json(*a)
+      Chef::JSONCompat.to_json(to_hash, *a)
     end
 
     def self.json_create(o)

data/lib/chef/application.rb

@@ -73,7 +73,6 @@ class Chef::Application
     end
   end
 
-
   # Parse configuration (options and config file)
   def configure_chef
     parse_options
@@ -219,30 +218,39 @@ class Chef::Application
   # Set ENV['http_proxy']
   def configure_http_proxy
     if http_proxy = Chef::Config[:http_proxy]
-      env['http_proxy'] = configure_proxy("http", http_proxy,
-        Chef::Config[:http_proxy_user], Chef::Config[:http_proxy_pass])
+      http_proxy_string = configure_proxy("http", http_proxy,
+          Chef::Config[:http_proxy_user], Chef::Config[:http_proxy_pass])
+      env['http_proxy'] = http_proxy_string unless env['http_proxy']
+      env['HTTP_PROXY'] = http_proxy_string unless env['HTTP_PROXY']
     end
   end
 
   # Set ENV['https_proxy']
   def configure_https_proxy
     if https_proxy = Chef::Config[:https_proxy]
-      env['https_proxy'] = configure_proxy("https", https_proxy,
-        Chef::Config[:https_proxy_user], Chef::Config[:https_proxy_pass])
+      https_proxy_string = configure_proxy("https", https_proxy,
+          Chef::Config[:https_proxy_user], Chef::Config[:https_proxy_pass])
+      env['https_proxy'] = https_proxy_string unless env['https_proxy']
+      env['HTTPS_PROXY'] = https_proxy_string unless env['HTTPS_PROXY']
     end
   end
 
   # Set ENV['ftp_proxy']
   def configure_ftp_proxy
     if ftp_proxy = Chef::Config[:ftp_proxy]
-      env['ftp_proxy'] = configure_proxy("ftp", ftp_proxy,
+      ftp_proxy_string = configure_proxy("ftp", ftp_proxy,
         Chef::Config[:ftp_proxy_user], Chef::Config[:ftp_proxy_pass])
+      env['ftp_proxy'] = ftp_proxy_string unless env['ftp_proxy']
+      env['FTP_PROXY'] = ftp_proxy_string unless env['FTP_PROXY']
     end
   end
 
   # Set ENV['no_proxy']
   def configure_no_proxy
-    env['no_proxy'] = Chef::Config[:no_proxy] if Chef::Config[:no_proxy]
+    if Chef::Config[:no_proxy]
+      env['no_proxy'] = Chef::Config[:no_proxy] unless env['no_proxy']
+      env['NO_PROXY'] = Chef::Config[:no_proxy] unless env['NO_PROXY']
+    end
   end
 
   # Builds a proxy uri. Examples:
@@ -256,7 +264,7 @@ class Chef::Application
   #   pass = password
   def configure_proxy(scheme, path, user, pass)
     begin
-      path = "#{scheme}://#{path}" unless path.start_with?(scheme)
+      path = "#{scheme}://#{path}" unless path.include?('://')
       # URI.split returns the following parts:
       # [scheme, userinfo, host, port, registry, path, opaque, query, fragment]
       parts = URI.split(URI.encode(path))

data/lib/chef/chef_fs/chef_fs_data_store.rb

@@ -269,7 +269,7 @@ class Chef
 
         # Create a little Chef::ChefFS memory filesystem with the data
         cookbook_fs = Chef::ChefFS::FileSystem::MemoryRoot.new('uploading')
-        cookbook = JSON.parse(data, :create_additions => false)
+        cookbook = Chef::JSONCompat.parse(data)
         cookbook.each_pair do |key, value|
           if value.is_a?(Array)
             value.each do |file|

data/lib/chef/chef_fs/command_line.rb

@@ -251,7 +251,7 @@ class Chef
       end
 
       def self.canonicalize_json(json_text)
-        parsed_json = JSON.parse(json_text, :create_additions => false)
+        parsed_json = Chef::JSONCompat.parse(json_text)
         sorted_json = sort_keys(parsed_json)
         JSON.pretty_generate(sorted_json)
       end

data/lib/chef/chef_fs/file_system.rb

@@ -369,7 +369,7 @@ class Chef
               end
             else
               if dest_entry.dir?
-                ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n") if ui
+                ui.error("File #{src_path} is a regular file while file #{dest_path} is a directory\n") if ui
                 return
               else
 

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

@@ -37,7 +37,7 @@ class Chef
 
         def write(file_contents)
           # ACL writes are fun.
-          acls = data_handler.normalize(JSON.parse(file_contents, :create_additions => false), self)
+          acls = data_handler.normalize(Chef::JSONCompat.parse(file_contents), self)
           PERMISSIONS.each do |permission|
             begin
               rest.put("#{api_path}/#{permission}", { permission => acls[permission] })

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

@@ -41,7 +41,7 @@ class Chef
 
         def chef_object
           begin
-            return data_handler.chef_object(JSON.parse(read, :create_additions => false))
+            return data_handler.chef_object(Chef::JSONCompat.parse(read))
           rescue
             Chef::Log.error("Could not read #{path_for_printing} into a Chef object: #{$!}")
           end
@@ -60,10 +60,10 @@ class Chef
         end
 
         def minimize(file_contents, entry)
-          object = JSONCompat.from_json(file_contents, :create_additions => false)
+          object = Chef::JSONCompat.from_json(file_contents)
           object = data_handler.normalize(object, entry)
           object = data_handler.minimize(object, entry)
-          JSONCompat.to_json_pretty(object)
+          Chef::JSONCompat.to_json_pretty(object)
         end
 
         def children

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

@@ -18,7 +18,7 @@
 
 require 'chef/chef_fs/file_system/base_fs_object'
 require 'chef/http/simple'
-require 'digest/md5'
+require 'openssl'
 
 class Chef
   module ChefFS
@@ -74,7 +74,7 @@ class Chef
         private
 
         def calc_checksum(value)
-          Digest::MD5.hexdigest(value)
+          OpenSSL::Digest::MD5.hexdigest(value)
         end
       end
     end

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

@@ -61,8 +61,8 @@ class Chef
 
         def create_child(name, file_contents)
           begin
-            object = JSON.parse(file_contents, :create_additions => false)
-          rescue JSON::ParserError => e
+            object = Chef::JSONCompat.parse(file_contents)
+          rescue Chef::Exceptions::JSON::ParseError => e
             raise Chef::ChefFS::FileSystem::OperationFailedError.new(:create_child, self, e), "Parse error reading JSON creating child '#{name}': #{e}"
           end
 

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

@@ -128,8 +128,8 @@ class Chef
           value = minimize_value(value)
           value_json = Chef::JSONCompat.to_json_pretty(value)
           begin
-            other_value = JSON.parse(other_value_json, :create_additions => false)
-          rescue JSON::ParserError => e
+            other_value = Chef::JSONCompat.parse(other_value_json)
+          rescue Chef::Exceptions::JSON::ParseError => e
             Chef::Log.warn("Parse error reading #{other.path_for_printing} as JSON: #{e}")
             return [ nil, value_json, other_value_json ]
           end
@@ -145,8 +145,8 @@ class Chef
 
         def write(file_contents)
           begin
-            object = JSON.parse(file_contents, :create_additions => false)
-          rescue JSON::ParserError => e
+            object = Chef::JSONCompat.parse(file_contents)
+          rescue Chef::Exceptions::JSON::ParseError => e
             raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e), "Parse error reading JSON: #{e}"
           end
 

data/lib/chef/config.rb

@@ -432,7 +432,8 @@ class Chef
     # format. Version "2" is available which adds encrypt-then-mac protection.
     # To maintain compatibility, versions other than 1 must be opt-in.
     #
-    # Set this to `2` if you have chef-client 11.6.0+ in your infrastructure:
+    # Set this to `2` if you have chef-client 11.6.0+ in your infrastructure.
+    # Set this to `3` if you have chef-client 11.?.0+, ruby 2 and OpenSSL >= 1.0.1 in your infrastructure. (TODO)
     default :data_bag_encrypt_version, 1
 
     # When reading data bag items, any supported version is accepted. However,
@@ -455,15 +456,15 @@ class Chef
     default :validation_client_name, "chef-validator"
 
     # When creating a new client via the validation_client account, Chef 11
-    # servers allow the client to generate a key pair locally and sent the
+    # servers allow the client to generate a key pair locally and send the
     # public key to the server. This is more secure and helps offload work from
     # the server, enhancing scalability. If enabled and the remote server
     # implements only the Chef 10 API, client registration will not work
     # properly.
     #
-    # The default value is `false` (Server generates client keys). Set to
-    # `true` to enable client-side key generation.
-    default(:local_key_generation) { false }
+    # The default value is `true`. Set to `false` to disable client-side key
+    # generation (server generates client keys).
+    default(:local_key_generation) { true }
 
     # Zypper package provider gpg checks. Set to true to enable package
     # gpg signature checking. This will be default in the

data/lib/chef/config_fetcher.rb

@@ -18,7 +18,7 @@ class Chef
       config_data = read_config
       begin
         Chef::JSONCompat.from_json(config_data)
-      rescue FFI_Yajl::ParseError => error
+      rescue Chef::Exceptions::JSON::ParseError => error
         Chef::Application.fatal!("Could not parse the provided JSON file (#{config_location}): " + error.message, 2)
       end
     end

data/lib/chef/cookbook/cookbook_version_loader.rb

@@ -18,21 +18,29 @@ class Chef
 
       UPLOADED_COOKBOOK_VERSION_FILE = ".uploaded-cookbook-version.json".freeze
 
-      attr_reader :cookbook_name
       attr_reader :cookbook_settings
       attr_reader :cookbook_paths
       attr_reader :metadata_filenames
       attr_reader :frozen
       attr_reader :uploaded_cookbook_version_file
 
+      attr_reader :cookbook_path
+
+      # The cookbook's name as inferred from its directory.
+      attr_reader :inferred_cookbook_name
+
+      attr_reader :metadata_error
+
       def initialize(path, chefignore=nil)
         @cookbook_path = File.expand_path( path ) # cookbook_path from which this was loaded
         # We keep a list of all cookbook paths that have been merged in
-        @cookbook_paths = [ @cookbook_path ]
-        @cookbook_name = File.basename( path )
+        @cookbook_paths = [ cookbook_path ]
+
+        @inferred_cookbook_name = File.basename( path )
         @chefignore = chefignore
-        @metadata = Hash.new
+        @metadata = nil
         @relative_path = /#{Regexp.escape(@cookbook_path)}\/(.+)$/
+        @metadata_loaded = false
         @cookbook_settings = {
           :attribute_filenames  => {},
           :definition_filenames => {},
@@ -46,9 +54,29 @@ class Chef
         }
 
         @metadata_filenames = []
+        @metadata_error = nil
+      end
+
+      # Load the cookbook. Raises an error if the cookbook_path given to the
+      # constructor doesn't point to a valid cookbook.
+      def load!
+        file_paths_map = load
+
+        if empty?
+          raise Exceptions::CookbookNotFoundInRepo, "The directory #{cookbook_path} does not contain a cookbook"
+        end
+        file_paths_map
       end
 
-      def load_cookbooks
+      # Load the cookbook. Does not raise an error if given a non-cookbook
+      # directory as the cookbook_path. This behavior is provided for
+      # compatibility, it is recommended to use #load! instead.
+      def load
+        metadata # force lazy evaluation to occur
+
+        # re-raise any exception that occurred when reading the metadata
+        raise_metadata_error!
+
         load_as(:attribute_filenames, 'attributes', '*.rb')
         load_as(:definition_filenames, 'definitions', '*.rb')
         load_as(:recipe_filenames, 'recipes', '*.rb')
@@ -61,31 +89,37 @@ class Chef
 
         remove_ignored_files
 
-        if File.exists?(File.join(@cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE))
-          @uploaded_cookbook_version_file = File.join(@cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE)
+        if empty?
+          Chef::Log.warn "found a directory #{cookbook_name} in the cookbook path, but it contains no cookbook files. skipping."
+        end
+        @cookbook_settings
+      end
+
+      alias :load_cookbooks :load
+
+      def metadata_filenames
+        return @metadata_filenames unless @metadata_filenames.empty?
+        if File.exists?(File.join(cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE))
+          @uploaded_cookbook_version_file = File.join(cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE)
         end
 
-        if File.exists?(File.join(@cookbook_path, "metadata.rb"))
-          @metadata_filenames << File.join(@cookbook_path, "metadata.rb")
-        elsif File.exists?(File.join(@cookbook_path, "metadata.json"))
-          @metadata_filenames << File.join(@cookbook_path, "metadata.json")
+        if File.exists?(File.join(cookbook_path, "metadata.rb"))
+          @metadata_filenames << File.join(cookbook_path, "metadata.rb")
+        elsif File.exists?(File.join(cookbook_path, "metadata.json"))
+          @metadata_filenames << File.join(cookbook_path, "metadata.json")
         elsif @uploaded_cookbook_version_file
           @metadata_filenames << @uploaded_cookbook_version_file
         end
 
         # Set frozen based on .uploaded-cookbook-version.json
         set_frozen
-
-        if empty?
-          Chef::Log.warn "found a directory #{cookbook_name} in the cookbook path, but it contains no cookbook files. skipping."
-        end
-        @cookbook_settings
+        @metadata_filenames
       end
 
       def cookbook_version
         return nil if empty?
 
-        Chef::CookbookVersion.new(@cookbook_name.to_sym, *@cookbook_paths).tap do |c|
+        Chef::CookbookVersion.new(cookbook_name, *cookbook_paths).tap do |c|
           c.attribute_filenames  = cookbook_settings[:attribute_filenames].values
           c.definition_filenames = cookbook_settings[:definition_filenames].values
           c.recipe_filenames     = cookbook_settings[:recipe_filenames].values
@@ -95,16 +129,32 @@ class Chef
           c.resource_filenames   = cookbook_settings[:resource_filenames].values
           c.provider_filenames   = cookbook_settings[:provider_filenames].values
           c.root_filenames       = cookbook_settings[:root_filenames].values
-          c.metadata_filenames   = @metadata_filenames
-          c.metadata             = metadata(c)
+          c.metadata_filenames   = metadata_filenames
+          c.metadata             = metadata
+
           c.freeze_version if @frozen
         end
       end
 
+      def cookbook_name
+        # The `name` attribute is now required in metadata, so
+        # inferred_cookbook_name generally should not be used. Per CHEF-2923,
+        # we have to not raise errors in cookbook metadata immediately, so that
+        # users can still `knife cookbook upload some-cookbook` when an
+        # unrelated cookbook has an error in its metadata.  This situation
+        # could prevent us from reading the `name` attribute from the metadata
+        # entirely, but the name is used as a hash key in CookbookLoader, so we
+        # fall back to the inferred name here.
+        (metadata.name || @inferred_cookbook_name).to_sym
+      end
+
       # Generates the Cookbook::Metadata object
-      def metadata(cookbook_version)
-        @metadata = Chef::Cookbook::Metadata.new(cookbook_version)
-        @metadata_filenames.each do |metadata_file|
+      def metadata
+        return @metadata unless @metadata.nil?
+
+        @metadata = Chef::Cookbook::Metadata.new
+
+        metadata_filenames.each do |metadata_file|
           case metadata_file
           when /\.rb$/
             apply_ruby_metadata(metadata_file)
@@ -116,51 +166,75 @@ class Chef
             raise RuntimeError, "Invalid metadata file: #{metadata_file} for cookbook: #{cookbook_version}"
           end
         end
+
+        @metadata
+
+        # Rescue errors so that users can upload cookbooks via `knife cookbook
+        # upload` even if some cookbooks in their chef-repo have errors in
+        # their metadata. We only rescue StandardError because you have to be
+        # doing something *really* terrible to raise an exception that inherits
+        # directly from Exception in your metadata.rb file.
+      rescue StandardError => e
+        @metadata_error = e
         @metadata
       end
 
+      def raise_metadata_error!
+        raise @metadata_error unless @metadata_error.nil?
+        # Metadata won't be valid if the cookbook is empty. If the cookbook is
+        # actually empty, a metadata error here would be misleading, so don't
+        # raise it (if called by #load!, a different error is raised).
+        if !empty? && !metadata.valid?
+          message = "Cookbook loaded at path(s) [#{@cookbook_paths.join(', ')}] has invalid metadata: #{metadata.errors.join('; ')}"
+          raise Exceptions::MetadataNotValid, message
+        end
+        false
+      end
+
       def empty?
-        @cookbook_settings.values.all? { |files_hash| files_hash.empty? } && @metadata_filenames.size == 0
+        cookbook_settings.values.all? { |files_hash| files_hash.empty? } && metadata_filenames.size == 0
       end
 
       def merge!(other_cookbook_loader)
         other_cookbook_settings = other_cookbook_loader.cookbook_settings
-        @cookbook_settings.each do |file_type, file_list|
+        cookbook_settings.each do |file_type, file_list|
           file_list.merge!(other_cookbook_settings[file_type])
         end
-        @metadata_filenames.concat(other_cookbook_loader.metadata_filenames)
+        metadata_filenames.concat(other_cookbook_loader.metadata_filenames)
         @cookbook_paths += other_cookbook_loader.cookbook_paths
         @frozen = true if other_cookbook_loader.frozen
+        @metadata = nil # reset metadata so it gets reloaded and all metadata files applied.
+        self
       end
 
       def chefignore
-        @chefignore ||= Chefignore.new(File.basename(@cookbook_path))
+        @chefignore ||= Chefignore.new(File.basename(cookbook_path))
       end
 
       def load_root_files
-        Dir.glob(File.join(@cookbook_path, '*'), File::FNM_DOTMATCH).each do |file|
+        Dir.glob(File.join(cookbook_path, '*'), File::FNM_DOTMATCH).each do |file|
           next if File.directory?(file)
           next if File.basename(file) == UPLOADED_COOKBOOK_VERSION_FILE
-          @cookbook_settings[:root_filenames][file[@relative_path, 1]] = file
+          cookbook_settings[:root_filenames][file[@relative_path, 1]] = file
         end
       end
 
       def load_recursively_as(category, category_dir, glob)
-        file_spec = File.join(@cookbook_path, category_dir, '**', glob)
+        file_spec = File.join(cookbook_path, category_dir, '**', glob)
         Dir.glob(file_spec, File::FNM_DOTMATCH).each do |file|
           next if File.directory?(file)
-          @cookbook_settings[category][file[@relative_path, 1]] = file
+          cookbook_settings[category][file[@relative_path, 1]] = file
         end
       end
 
       def load_as(category, *path_glob)
-        Dir[File.join(@cookbook_path, *path_glob)].each do |file|
-          @cookbook_settings[category][file[@relative_path, 1]] = file
+        Dir[File.join(cookbook_path, *path_glob)].each do |file|
+          cookbook_settings[category][file[@relative_path, 1]] = file
         end
       end
 
       def remove_ignored_files
-        @cookbook_settings.each_value do |file_list|
+        cookbook_settings.each_value do |file_list|
           file_list.reject! do |relative_path, full_path|
             chefignore.ignored?(relative_path)
           end
@@ -170,8 +244,8 @@ class Chef
       def apply_ruby_metadata(file)
         begin
           @metadata.from_file(file)
-        rescue JSON::ParserError
-          Chef::Log.error("Error evaluating metadata.rb for #@cookbook_name in " + file)
+        rescue Chef::Exceptions::JSON::ParseError
+          Chef::Log.error("Error evaluating metadata.rb for #@inferred_cookbook_name in " + file)
           raise
         end
       end
@@ -179,18 +253,27 @@ class Chef
       def apply_json_metadata(file)
         begin
           @metadata.from_json(IO.read(file))
-        rescue JSON::ParserError
-          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@cookbook_name in " + file)
+        rescue Chef::Exceptions::JSON::ParseError
+          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@inferred_cookbook_name in " + file)
           raise
         end
       end
 
       def apply_json_cookbook_version_metadata(file)
         begin
-          data = Chef::JSONCompat.from_json(IO.read(file), :create_additions => false)
+          data = Chef::JSONCompat.parse(IO.read(file))
           @metadata.from_hash(data['metadata'])
-        rescue JSON::ParserError
-          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@cookbook_name in " + file)
+          # the JSON cookbok metadata file is only used by chef-zero.
+          # The Chef Server API currently does not enforce that the metadata
+          # have a `name` field, but that will cause an error when attempting
+          # to load the cookbook. To keep compatibility, we fake it by setting
+          # the metadata name from the cookbook version object's name.
+          #
+          # This behavior can be removed if/when Chef Server enforces that the
+          # metadata contains a name key.
+          @metadata.name(data['cookbook_name']) unless data['metadata'].key?('name')
+        rescue Chef::Exceptions::JSON::ParseError
+          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@inferred_cookbook_name in " + file)
           raise
         end
       end
@@ -198,10 +281,10 @@ class Chef
       def set_frozen
         if uploaded_cookbook_version_file
           begin
-            data = Chef::JSONCompat.from_json(IO.read(uploaded_cookbook_version_file), :create_additions => false)
+            data = Chef::JSONCompat.parse(IO.read(uploaded_cookbook_version_file))
             @frozen = data['frozen?']
-          rescue JSON::ParserError
-            Chef::Log.error("Couldn't parse cookbook metadata JSON for #@cookbook_name in #{uploaded_cookbook_version_file}")
+          rescue Chef::Exceptions::JSON::ParseError
+            Chef::Log.error("Couldn't parse cookbook metadata JSON for #@inferred_cookbook_name in #{uploaded_cookbook_version_file}")
             raise
           end
         end