chef 13.12.14 → 14.0.190

data/lib/chef/application/solo.rb

@@ -1,7 +1,7 @@
 #
 # Author:: AJ Christensen (<aj@chef.io>)
 # Author:: Mark Mzyk (mmzyk@chef.io)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -175,8 +175,7 @@ class Chef::Application::Solo < Chef::Application
   option :client_fork,
     :short        => "-f",
     :long         => "--[no-]fork",
-    :description  => "Fork client",
-    :boolean      => true
+    :description  => "Fork client"
 
   option :why_run,
     :short        => "-W",
@@ -238,19 +237,12 @@ class Chef::Application::Solo < Chef::Application
 
     Chef::Config[:solo] = true
 
-    Chef::Log.deprecation("-r MUST be changed to --recipe-url, the -r option will be changed in Chef 13.0") if ARGV.include?("-r")
-
     if !Chef::Config[:solo_legacy_mode]
       # Because we re-parse ARGV when we move to chef-client, we need to tidy up some options first.
       ARGV.delete("--ez")
 
-      # -r means something entirely different in chef-client land, so let's replace it with a "safe" value
-      if dash_r = ARGV.index("-r")
-        ARGV[dash_r] = "--recipe-url"
-      end
-
       # For back compat reasons, we need to ensure that we try and use the cache_path as a repo first
-      Chef::Log.debug "Current chef_repo_path is #{Chef::Config.chef_repo_path}"
+      Chef::Log.trace "Current chef_repo_path is #{Chef::Config.chef_repo_path}"
 
       if !Chef::Config.has_key?(:cookbook_path) && !Chef::Config.has_key?(:chef_repo_path)
         Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Chef::Config[:cache_path])
@@ -268,6 +260,11 @@ class Chef::Application::Solo < Chef::Application
       Chef::Config[:interval] ||= 1800
     end
 
+    # supervisor processes are enabled by default for interval-running processes but not for one-shot runs
+    if Chef::Config[:client_fork].nil?
+      Chef::Config[:client_fork] = !!Chef::Config[:interval]
+    end
+
     Chef::Application.fatal!(unforked_interval_error_message) if !Chef::Config[:client_fork] && Chef::Config[:interval]
 
     if Chef::Config[:recipe_url]
@@ -275,10 +272,10 @@ class Chef::Application::Solo < Chef::Application
       recipes_path = File.expand_path(File.join(cookbooks_path, ".."))
 
       if Chef::Config[:delete_entire_chef_repo]
-        Chef::Log.debug "Cleanup path #{recipes_path} before extract recipes into it"
+        Chef::Log.trace "Cleanup path #{recipes_path} before extract recipes into it"
         FileUtils.rm_rf(recipes_path, :secure => true)
       end
-      Chef::Log.debug "Creating path #{recipes_path} to extract recipes into"
+      Chef::Log.trace "Creating path #{recipes_path} to extract recipes into"
       FileUtils.mkdir_p(recipes_path)
       tarball_path = File.join(recipes_path, "recipes.tgz")
       fetch_recipe_tarball(Chef::Config[:recipe_url], tarball_path)
@@ -339,7 +336,7 @@ EOH
         sleep_sec += rand(Chef::Config[:splay]) if Chef::Config[:splay]
         sleep_sec += Chef::Config[:interval] if Chef::Config[:interval]
         if sleep_sec != 0
-          Chef::Log.debug("Sleeping for #{sleep_sec} seconds")
+          Chef::Log.trace("Sleeping for #{sleep_sec} seconds")
           sleep(sleep_sec)
         end
 
@@ -352,7 +349,7 @@ EOH
       rescue Exception => e
         if Chef::Config[:interval]
           Chef::Log.error("#{e.class}: #{e}")
-          Chef::Log.debug("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
+          Chef::Log.trace("#{e.class}: #{e}\n#{e.backtrace.join("\n")}")
           retry
         else
           Chef::Application.fatal!("#{e.class}: #{e.message}", e)
@@ -362,7 +359,7 @@ EOH
   end
 
   def fetch_recipe_tarball(url, path)
-    Chef::Log.debug("Download recipes tarball from #{url} to #{path}")
+    Chef::Log.trace("Download recipes tarball from #{url} to #{path}")
     File.open(path, "wb") do |f|
       open(url) do |r|
         f.write(r.read)

data/lib/chef/application/windows_service.rb

@@ -109,9 +109,9 @@ class Chef
 
         # Daemon class needs to have all the signal callbacks return
         # before service_main returns.
-        Chef::Log.debug("Giving signal callbacks some time to exit...")
+        Chef::Log.trace("Giving signal callbacks some time to exit...")
         sleep 1
-        Chef::Log.debug("Exiting service...")
+        Chef::Log.trace("Exiting service...")
       end
 
       ################################################################################
@@ -135,7 +135,7 @@ class Chef
               run_warning_displayed = true
             end
 
-            Chef::Log.debug("Waiting for chef-client run...")
+            Chef::Log.trace("Waiting for chef-client run...")
             sleep 1
           end
         end
@@ -200,8 +200,8 @@ class Chef
           :timeout => Chef::Config[:windows_service][:watchdog_timeout],
           :logger => Chef::Log
         )
-        Chef::Log.debug "#{result.stdout}"
-        Chef::Log.debug "#{result.stderr}"
+        Chef::Log.trace "#{result.stdout}"
+        Chef::Log.trace "#{result.stderr}"
       rescue Mixlib::ShellOut::CommandTimeout => e
         Chef::Log.error "chef-client timed out\n(#{e})"
         Chef::Log.error(<<-EOF)

data/lib/chef/audit/audit_event_proxy.rb

@@ -37,7 +37,7 @@ class Chef
         if notification.group.parent_groups.size == 1
           # top level `control_group` block
           desc = notification.group.description
-          Chef::Log.debug("Entered `control_group` block named #{desc}")
+          Chef::Log.trace("Entered `control_group` block named #{desc}")
           events.control_group_started(desc)
         end
       end

data/lib/chef/audit/audit_reporter.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Tyler Ball (<tball@chef.io>)
 #
-# Copyright:: Copyright 2014-2016, Chef Software, Inc.
+# Copyright:: Copyright 2014-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -42,14 +42,14 @@ class Chef
       end
 
       def audit_phase_start(run_status)
-        Chef::Log.debug("Audit Reporter starting")
+        Chef::Log.trace("Audit Reporter starting")
         @audit_data = AuditData.new(run_status.node.name, run_status.run_id)
         @run_status = run_status
       end
 
       def audit_phase_complete(audit_output)
-        Chef::Log.debug("Audit Reporter completed successfully without errors.")
-        ordered_control_groups.each do |name, control_group|
+        Chef::Log.trace("Audit Reporter completed successfully without errors.")
+        ordered_control_groups.each_value do |control_group|
           audit_data.add_control_group(control_group)
         end
       end
@@ -61,8 +61,8 @@ class Chef
       def audit_phase_failed(error, audit_output)
         # The stacktrace information has already been logged elsewhere
         @audit_phase_error = error
-        Chef::Log.debug("Audit Reporter failed.")
-        ordered_control_groups.each do |name, control_group|
+        Chef::Log.trace("Audit Reporter failed.")
+        ordered_control_groups.each_value do |control_group|
           audit_data.add_control_group(control_group)
         end
       end
@@ -104,12 +104,12 @@ class Chef
 
       def post_auditing_data
         unless auditing_enabled?
-          Chef::Log.debug("Audit Reports are disabled. Skipping sending reports.")
+          Chef::Log.trace("Audit Reports are disabled. Skipping sending reports.")
           return
         end
 
         unless run_status
-          Chef::Log.debug("Run failed before audit mode was initialized, not sending audit report to server")
+          Chef::Log.trace("Run failed before audit mode was initialized, not sending audit report to server")
           return
         end
 
@@ -117,7 +117,7 @@ class Chef
         audit_data.end_time = iso8601ify(run_status.end_time)
 
         audit_history_url = "controls"
-        Chef::Log.debug("Sending audit report (run-id: #{audit_data.run_id})")
+        Chef::Log.trace("Sending audit report (run-id: #{audit_data.run_id})")
         run_data = audit_data.to_hash
 
         if @audit_phase_error
@@ -126,7 +126,7 @@ class Chef
           run_data[:error] = error_info
         end
 
-        Chef::Log.debug "Audit Report:\n#{Chef::JSONCompat.to_json_pretty(run_data)}"
+        Chef::Log.trace "Audit Report:\n#{Chef::JSONCompat.to_json_pretty(run_data)}"
         begin
           rest_client.post(audit_history_url, run_data, headers)
         rescue StandardError => e
@@ -134,14 +134,14 @@ class Chef
             # 404 error code is OK. This means the version of server we're running against doesn't support
             # audit reporting. Don't alarm failure in this case.
             if e.response.code == "404"
-              Chef::Log.debug("Server doesn't support audit reporting. Skipping report.")
+              Chef::Log.trace("Server doesn't support audit reporting. Skipping report.")
               return
             else
               # Save the audit report to local disk
               error_file = "failed-audit-data.json"
               Chef::FileCache.store(error_file, Chef::JSONCompat.to_json_pretty(run_data), 0640)
               if Chef::Config.chef_zero.enabled
-                Chef::Log.debug("Saving audit report to #{Chef::FileCache.load(error_file, false)}")
+                Chef::Log.trace("Saving audit report to #{Chef::FileCache.load(error_file, false)}")
               else
                 Chef::Log.error("Failed to post audit report to server. Saving report to #{Chef::FileCache.load(error_file, false)}")
               end

data/lib/chef/audit/runner.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Claire McQuin (<claire@chef.io>)
-# Copyright:: Copyright 2014-2016, Chef Software, Inc.
+# Copyright:: Copyright 2014-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -163,7 +163,7 @@ class Chef
       # or use example group filters.
       def register_control_groups
         add_example_group_methods
-        run_context.audits.each do |name, group|
+        run_context.audits.each do |name, group| # rubocop:disable Performance/HashEachMethods
           ctl_grp = RSpec::Core::ExampleGroup.__control_group__(*group.args, &group.block)
           RSpec.world.record(ctl_grp)
         end

data/lib/chef/chef_fs/chef_fs_data_store.rb

@@ -307,11 +307,16 @@ class Chef
 
         # GET /cookbooks/NAME/VERSION or /cookbook_artifacts/NAME/IDENTIFIER
         elsif %w{cookbooks cookbook_artifacts}.include?(path[0]) && path.length == 3
-          with_entry(path) do |entry|
+          with_entry([path[0]]) do |entry|
             cookbook_type = path[0]
+            cookbook_entry = entry.children.select do |child|
+              child.chef_object.full_name == "#{path[1]}-#{path[2]}" ||
+                (child.chef_object.name.to_s == path[1] && child.chef_object.identifier == path[2])
+            end[0]
+            raise ChefZero::DataStore::DataNotFoundError.new(path) if cookbook_entry.nil?
             result = nil
             begin
-              result = Chef::CookbookManifest.new(entry.chef_object, policy_mode: cookbook_type == "cookbook_artifacts").to_hash
+              result = Chef::CookbookManifest.new(cookbook_entry.chef_object, policy_mode: cookbook_type == "cookbook_artifacts").to_hash
             rescue Chef::ChefFS::FileSystem::NotFoundError => e
               raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
             end
@@ -320,12 +325,7 @@ class Chef
               if value.is_a?(Array)
                 value.each do |file|
                   if file.is_a?(Hash) && file.has_key?("checksum")
-                    relative = ["file_store", "repo", cookbook_type]
-                    if chef_fs.versioned_cookbooks || cookbook_type == "cookbook_artifacts"
-                      relative << "#{path[1]}-#{path[2]}"
-                    else
-                      relative << path[1]
-                    end
+                    relative = ["file_store", "repo", cookbook_type, cookbook_entry.name ]
                     relative += file[:path].split("/")
                     file["url"] = ChefZero::RestBase.build_uri(request.base_uri, relative)
                   end
@@ -519,14 +519,7 @@ class Chef
         elsif %w{cookbooks cookbook_artifacts}.include?(path[0]) && path.length == 1
           with_entry(path) do |entry|
             begin
-              if path[0] == "cookbook_artifacts"
-                entry.children.map { |child| child.name.rpartition("-")[0] }.uniq
-              elsif chef_fs.versioned_cookbooks
-                # /cookbooks/name-version -> /cookbooks/name
-                entry.children.map { |child| split_name_version(child.name)[0] }.uniq
-              else
-                entry.children.map { |child| child.name }
-              end
+              entry.children.map { |child| child.chef_object.name.to_s }.uniq
             rescue Chef::ChefFS::FileSystem::NotFoundError
               # If the cookbooks dir doesn't exist, we have no cookbooks (not 404)
               []
@@ -534,22 +527,15 @@ class Chef
           end
 
         elsif %w{cookbooks cookbook_artifacts}.include?(path[0]) && path.length == 2
-          if chef_fs.versioned_cookbooks || path[0] == "cookbook_artifacts"
-            result = with_entry([ path[0] ]) do |entry|
-              # list /cookbooks/name = filter /cookbooks/name-version down to name
-              entry.children.map { |child| split_name_version(child.name) }.
-              select { |name, version| name == path[1] }.
-              map { |name, version| version }
-            end
-            if result.empty?
-              raise ChefZero::DataStore::DataNotFoundError.new(path)
-            end
-            result
-          else
-            # list /cookbooks/name = <single version>
-            version = get_single_cookbook_version(path)
-            [version]
+          result = with_entry([ path[0] ]) do |entry|
+            cookbooks = entry.children.map { |child| child.chef_object }
+            cookbooks.select { |cookbook| cookbook.name.to_s == path[1] }.
+            map { |cookbook| cookbook.version }
           end
+          if result.empty?
+            raise ChefZero::DataStore::DataNotFoundError.new(path)
+          end
+          result
 
         else
           result = with_entry(path) do |entry|

data/lib/chef/chef_fs/command_line.rb

@@ -146,38 +146,38 @@ class Chef
         if old_entry.dir?
           if new_entry.dir?
             if recurse_depth == 0
-              return [ [ :common_subdirectories, old_entry, new_entry ] ]
+              [ [ :common_subdirectories, old_entry, new_entry ] ]
             else
-              return Chef::ChefFS::Parallelizer.parallelize(Chef::ChefFS::FileSystem.child_pairs(old_entry, new_entry)) do |old_child, new_child|
+              Chef::ChefFS::Parallelizer.parallelize(Chef::ChefFS::FileSystem.child_pairs(old_entry, new_entry)) do |old_child, new_child|
                 Chef::ChefFS::CommandLine.diff_entries(old_child, new_child, recurse_depth ? recurse_depth - 1 : nil, get_content)
               end.flatten(1)
             end
 
           # If old is a directory and new is a file
           elsif new_entry.exists?
-            return [ [ :directory_to_file, old_entry, new_entry ] ]
+            [ [ :directory_to_file, old_entry, new_entry ] ]
 
           # If old is a directory and new does not exist
           elsif new_entry.parent.can_have_child?(old_entry.name, old_entry.dir?)
-            return [ [ :deleted, old_entry, new_entry ] ]
+            [ [ :deleted, old_entry, new_entry ] ]
 
           # If the new entry does not and *cannot* exist, report that.
           else
-            return [ [ :new_cannot_upload, old_entry, new_entry ] ]
+            [ [ :new_cannot_upload, old_entry, new_entry ] ]
           end
 
         # If new is a directory and old is a file
         elsif new_entry.dir?
           if old_entry.exists?
-            return [ [ :file_to_directory, old_entry, new_entry ] ]
+            [ [ :file_to_directory, old_entry, new_entry ] ]
 
           # If new is a directory and old does not exist
           elsif old_entry.parent.can_have_child?(new_entry.name, new_entry.dir?)
-            return [ [ :added, old_entry, new_entry ] ]
+            [ [ :added, old_entry, new_entry ] ]
 
           # If the new entry does not and *cannot* exist, report that.
           else
-            return [ [ :old_cannot_upload, old_entry, new_entry ] ]
+            [ [ :old_cannot_upload, old_entry, new_entry ] ]
           end
 
         # Neither is a directory, so they are diffable with file diff
@@ -239,7 +239,7 @@ class Chef
           end
         end
       rescue Chef::ChefFS::FileSystem::FileSystemError => e
-        return [ [ :error, old_entry, new_entry, nil, nil, e ] ]
+        [ [ :error, old_entry, new_entry, nil, nil, e ] ]
       end
 
       class << self

data/lib/chef/chef_fs/data_handler/acl_data_handler.rb

@@ -13,7 +13,7 @@ class Chef
             "delete" => {},
             "grant" => {},
             })
-          result.keys.each do |key|
+          result.each_key do |key|
             result[key] = normalize_hash(result[key], { "actors" => [], "groups" => [] })
             result[key]["actors"] = result[key]["actors"].sort
             result[key]["groups"] = result[key]["groups"].sort

data/lib/chef/chef_fs/data_handler/policy_data_handler.rb

@@ -28,7 +28,7 @@ class Chef
 
         # Verify that the JSON hash for this type has a key that matches its name.
         #
-        # @param object [Object] JSON hash of the object
+        # @param object_data [Object] JSON hash of the object
         # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
         # @yield  [s] callback to handle errors
         # @yieldparam [s<string>] error message

data/lib/chef/chef_fs/data_handler/policy_group_data_handler.rb

@@ -17,7 +17,7 @@ class Chef
 
         # Verify that the JSON hash for this type has a key that matches its name.
         #
-        # @param object [Object] JSON hash of the object
+        # @param object_data [Object] JSON hash of the object
         # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
         # @yield  [s] callback to handle errors
         # @yieldparam [s<string>] error message