chef 16.3.45 → 16.4.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa52945033634387a28122cfa4c3dbff39dba44e788c8034af8ed4a745e6ff24
-  data.tar.gz: 5c5c7ad76d2d6d9eae974a75cf7f60a3e98a9a722bfa630896450759bea1a6b4
+  metadata.gz: 5cd173a8bc2e595b0c39776bd219be73951547e20a8ea7ca42e10ab9f4caf301
+  data.tar.gz: 8868bce6fe0f624417e2b431bdd0bd160b7747f1801ce93a2ab73b9225c210dc
 SHA512:
-  metadata.gz: d127cbfd546e55bc03903fedaa70650dc1c87f39152431d2da1f786f9d42c2335e07f496fd71c8b7b71ac5d674dc10307281c870e4b4d17150da9ce3d20d164b
-  data.tar.gz: 2a3713fbc7c46f17860be2a074f4b7f4b95795e799d6d7dfcde720b66188dcd0096432a73bebbeaa17bda264b7c5130a4eb1be0c2e879344db19d6fca13a2246
+  metadata.gz: 2880171bce3ce18571abc3142417189f5a31f768adfa4654a1d7b3bf7acdee3483032bd0b5da61e895cb3c1613cccbf95edd76788a44bc2290fe0e4c6823534b
+  data.tar.gz: c1d9c41879c5db64c0d104cc41ceb8c3c97a7188d6d2f11333ef33b06ec4574833e586a507c5f1dbbf3c0da43f6df97e462c1c54983cccabdba98075437425f5

data/chef-universal-mingw32.gemspec

@@ -3,7 +3,6 @@ gemspec = eval(IO.read(File.expand_path("chef.gemspec", __dir__)))
 gemspec.platform = Gem::Platform.new(%w{universal mingw32})
 
 gemspec.add_dependency "win32-api", "~> 1.5.3"
-gemspec.add_dependency "win32-dir", "~> 0.5.0"
 gemspec.add_dependency "win32-event", "~> 0.6.1"
 # TODO: Relax this pin and make the necessary updaets. The issue originally
 # leading to this pin has been fixed in 0.6.5.

data/lib/chef/action_collection.rb

@@ -44,6 +44,9 @@ class Chef
       # @return [Exception] The exception that was thrown
       attr_accessor :exception
 
+      # @return [Hash] JSON-formatted error description from the Chef::Formatters::ErrorMapper
+      attr_accessor :error_description
+
       # @return [Numeric] The elapsed time in seconds with machine precision
       attr_accessor :elapsed_time
 
@@ -223,6 +226,7 @@ class Chef
 
       current_record.status = :failed
       current_record.exception = exception
+      current_record.error_description = Formatters::ErrorMapper.resource_failed(new_resource, action, exception).for_json
     end
 
     # Hook called after an action is completed.  This is always called, even if the action fails.

data/lib/chef/api_client/registration.rb

@@ -72,14 +72,14 @@ class Chef
 
       def assert_destination_writable!
         abs_path = File.expand_path(destination)
-        unless File.exists?(File.dirname(abs_path))
+        unless File.exist?(File.dirname(abs_path))
           begin
             FileUtils.mkdir_p(File.dirname(abs_path))
           rescue Errno::EACCES
             raise Chef::Exceptions::CannotWritePrivateKey, "I can't create the configuration directory at #{File.dirname(abs_path)} - check permissions?"
           end
         end
-        if (File.exists?(abs_path) && !File.writable?(abs_path)) || !File.writable?(File.dirname(abs_path))
+        if (File.exist?(abs_path) && !File.writable?(abs_path)) || !File.writable?(File.dirname(abs_path))
           raise Chef::Exceptions::CannotWritePrivateKey, "I can't write your private key to #{abs_path} - check permissions?"
         end
       end
@@ -157,12 +157,12 @@ class Chef
       end
 
       def http_api
-        @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url],
-          {
-            api_version: "0",
-            client_name: Chef::Config[:validation_client_name],
-            signing_key_filename: Chef::Config[:validation_key],
-          })
+        options = {}
+        options[:api_version] = "0"
+        options[:client_name] = Chef::Config[:validation_client_name]
+        options[:raw_key] = Chef::Config[:validation_key_contents]
+        options[:signing_key_filename] = Chef::Config[:validation_key] unless options[:raw_key]
+        @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], options)
       end
 
       # Whether or not to generate keys locally and post the public key to the

data/lib/chef/application.rb

@@ -19,13 +19,14 @@
 require "pp" unless defined?(PP)
 require "socket" unless defined?(Socket)
 require_relative "config"
+require "chef-config/mixin/chef_cloud"
 require_relative "exceptions"
 require_relative "local_mode"
 require_relative "log"
 require_relative "platform"
 require "mixlib/cli" unless defined?(Mixlib::CLI)
 require "tmpdir" unless defined?(Dir.mktmpdir)
-require "rbconfig"
+require "rbconfig" unless defined?(RbConfig)
 require_relative "application/exit_code"
 require_relative "dist"
 require "license_acceptance/acceptor"
@@ -136,6 +137,10 @@ class Chef
 
       if config[:config_file].nil?
         logger.warn("No config file found or specified on command line. Using command line options instead.")
+      elsif ChefConfig::Mixin::ChefCloud.cloud_config?
+        logger.warn("*****************************************")
+        logger.warn("Found Chef Cloud configuration. Overriding local values from cloud.")
+        logger.warn("*****************************************")
       elsif config_fetcher.config_missing?
         logger.warn("*****************************************")
         logger.warn("Did not find config file: #{config[:config_file]}. Using command line options instead.")

data/lib/chef/application/apply.rb

@@ -213,11 +213,11 @@ class Chef::Application::Apply < Chef::Application
     end
     runner = Chef::Runner.new(run_context)
     catch(:end_client_run_early) do
-      begin
-        runner.converge
-      ensure
-        @recipe_fh.close
-      end
+
+      runner.converge
+    ensure
+      @recipe_fh.close
+
     end
     Chef::Platform::Rebooter.reboot_if_needed!(runner)
   end

data/lib/chef/application/base.rb

@@ -22,6 +22,7 @@ require_relative "../mixin/shell_out"
 require_relative "../config_fetcher"
 require_relative "../dist"
 require_relative "../daemon"
+require "chef-config/mixin/chef_cloud"
 require "chef-config/mixin/dot_d"
 require "license_acceptance/cli_flags/mixlib_cli"
 require "mixlib/archive" unless defined?(Mixlib::Archive)
@@ -39,6 +40,7 @@ require "mixlib/archive" unless defined?(Mixlib::Archive)
 #
 class Chef::Application::Base < Chef::Application
   include Chef::Mixin::ShellOut
+  include ChefConfig::Mixin::ChefCloud
   include ChefConfig::Mixin::DotD
   include LicenseAcceptance::CLIFlags::MixlibCLI
 

data/lib/chef/application/client.rb

@@ -156,6 +156,9 @@ class Chef::Application::Client < Chef::Application::Base
 
     # Load all config files in client.d
     load_dot_d(Chef::Config[:client_d_dir]) if Chef::Config[:client_d_dir]
+
+    # Load cloud config if present
+    load_cloud_config
   end
 
   def configure_logging

data/lib/chef/application/windows_service.rb

@@ -78,33 +78,33 @@ class Chef
         while running?
           # Grab the service_action_mutex to make a chef-client run
           @service_action_mutex.synchronize do
-            begin
-              Chef::Log.info("Next #{Chef::Dist::CLIENT} run will happen in #{timeout} seconds")
-              @service_signal.wait(@service_action_mutex, timeout)
-
-              # Continue only if service is RUNNING
-              next if state != RUNNING
-
-              # Reconfigure each time through to pick up any changes in the client file
-              Chef::Log.info("Reconfiguring with startup parameters")
-              reconfigure(startup_parameters)
-              timeout = Chef::Config[:interval]
-
-              # Honor splay sleep config
-              timeout += rand Chef::Config[:splay]
-
-              # run chef-client only if service is in RUNNING state
-              next if state != RUNNING
-
-              Chef::Log.info("#{Chef::Dist::CLIENT} service is starting a #{Chef::Dist::CLIENT} run...")
-              run_chef_client
-            rescue SystemExit => e
-              # Do not raise any of the errors here in order to
-              # prevent service crash
-              Chef::Log.error("#{e.class}: #{e}")
-            rescue Exception => e
-              Chef::Log.error("#{e.class}: #{e}")
-            end
+
+            Chef::Log.info("Next #{Chef::Dist::CLIENT} run will happen in #{timeout} seconds")
+            @service_signal.wait(@service_action_mutex, timeout)
+
+            # Continue only if service is RUNNING
+            next if state != RUNNING
+
+            # Reconfigure each time through to pick up any changes in the client file
+            Chef::Log.info("Reconfiguring with startup parameters")
+            reconfigure(startup_parameters)
+            timeout = Chef::Config[:interval]
+
+            # Honor splay sleep config
+            timeout += rand Chef::Config[:splay]
+
+            # run chef-client only if service is in RUNNING state
+            next if state != RUNNING
+
+            Chef::Log.info("#{Chef::Dist::CLIENT} service is starting a #{Chef::Dist::CLIENT} run...")
+            run_chef_client
+          rescue SystemExit => e
+            # Do not raise any of the errors here in order to
+            # prevent service crash
+            Chef::Log.error("#{e.class}: #{e}")
+          rescue Exception => e
+            Chef::Log.error("#{e.class}: #{e}")
+
           end
         end
 

data/lib/chef/chef_class.rb

@@ -32,7 +32,6 @@ require_relative "platform/provider_handler_map"
 require_relative "platform/resource_handler_map"
 require_relative "deprecated"
 require_relative "event_dispatch/dsl"
-require_relative "deprecated"
 
 class Chef
   class << self

data/lib/chef/chef_fs/chef_fs_data_store.rb

@@ -172,11 +172,11 @@ class Chef
           @memory_store.create_dir(path, name, *options)
         else
           with_parent_dir(path + [name], *options) do |parent, name|
-            begin
-              parent.create_child(name, nil)
-            rescue Chef::ChefFS::FileSystem::AlreadyExistsError => e
-              raise ChefZero::DataStore::DataAlreadyExistsError.new(to_zero_path(e.entry), e)
-            end
+
+            parent.create_child(name, nil)
+          rescue Chef::ChefFS::FileSystem::AlreadyExistsError => e
+            raise ChefZero::DataStore::DataAlreadyExistsError.new(to_zero_path(e.entry), e)
+
           end
         end
       end
@@ -251,11 +251,11 @@ class Chef
           end
 
           with_parent_dir(path + [name], *options) do |parent, name|
-            begin
-              parent.create_child(name, data)
-            rescue Chef::ChefFS::FileSystem::AlreadyExistsError => e
-              raise ChefZero::DataStore::DataAlreadyExistsError.new(to_zero_path(e.entry), e)
-            end
+
+            parent.create_child(name, data)
+          rescue Chef::ChefFS::FileSystem::AlreadyExistsError => e
+            raise ChefZero::DataStore::DataAlreadyExistsError.new(to_zero_path(e.entry), e)
+
           end
         end
       end
@@ -349,11 +349,11 @@ class Chef
 
         else
           with_entry(path) do |entry|
-            begin
-              entry.read
-            rescue Chef::ChefFS::FileSystem::NotFoundError => e
-              raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
-            end
+
+            entry.read
+          rescue Chef::ChefFS::FileSystem::NotFoundError => e
+            raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
+
           end
         end
       end
@@ -433,15 +433,15 @@ class Chef
 
         else
           with_entry(path) do |entry|
-            begin
-              if %w{cookbooks cookbook_artifacts}.include?(path[0]) && path.length >= 3
-                entry.delete(true)
-              else
-                entry.delete(false)
-              end
-            rescue Chef::ChefFS::FileSystem::NotFoundError => e
-              raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
+
+            if %w{cookbooks cookbook_artifacts}.include?(path[0]) && path.length >= 3
+              entry.delete(true)
+            else
+              entry.delete(false)
             end
+          rescue Chef::ChefFS::FileSystem::NotFoundError => e
+            raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
+
           end
         end
       end
@@ -471,11 +471,11 @@ class Chef
 
         else
           with_entry(path) do |entry|
-            begin
-              entry.delete(options.include?(:recursive))
-            rescue Chef::ChefFS::FileSystem::NotFoundError => e
-              raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
-            end
+
+            entry.delete(options.include?(:recursive))
+          rescue Chef::ChefFS::FileSystem::NotFoundError => e
+            raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
+
           end
         end
       end
@@ -487,11 +487,11 @@ class Chef
         # LIST /policies
         elsif path == [ "policies" ]
           with_entry([ path[0] ]) do |policies|
-            begin
-              policies.children.map { |policy| policy.name[0..-6].rpartition("-")[0] }.uniq
-            rescue Chef::ChefFS::FileSystem::NotFoundError
-              []
-            end
+
+            policies.children.map { |policy| policy.name[0..-6].rpartition("-")[0] }.uniq
+          rescue Chef::ChefFS::FileSystem::NotFoundError
+            []
+
           end
 
         # LIST /policies/POLICY/revisions
@@ -524,19 +524,19 @@ 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(&:name)
-              end
-            rescue Chef::ChefFS::FileSystem::NotFoundError
-              # If the cookbooks dir doesn't exist, we have no cookbooks (not 404)
-              []
+
+            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(&:name)
             end
+          rescue Chef::ChefFS::FileSystem::NotFoundError
+            # If the cookbooks dir doesn't exist, we have no cookbooks (not 404)
+            []
+
           end
 
         elsif %w{cookbooks cookbook_artifacts}.include?(path[0]) && path.length == 2
@@ -560,16 +560,16 @@ class Chef
 
         else
           result = with_entry(path) do |entry|
-            begin
-              entry.children.map { |c| zero_filename(c) }.sort
-            rescue Chef::ChefFS::FileSystem::NotFoundError => e
-              # /cookbooks, /data, etc. never return 404
-              if path_always_exists?(path)
-                []
-              else
-                raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
-              end
+
+            entry.children.map { |c| zero_filename(c) }.sort
+          rescue Chef::ChefFS::FileSystem::NotFoundError => e
+            # /cookbooks, /data, etc. never return 404
+            if path_always_exists?(path)
+              []
+            else
+              raise ChefZero::DataStore::DataNotFoundError.new(to_zero_path(e.entry), e)
             end
+
           end
 
           # Older versions of chef-zero do not understand policies and cookbook_artifacts,

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

@@ -47,17 +47,17 @@ class Chef
             # ACL writes are fun.
             acls = data_handler.normalize(Chef::JSONCompat.parse(file_contents), self)
             PERMISSIONS.each do |permission|
-              begin
-                rest.put("#{api_path}/#{permission}", { permission => acls[permission] })
-              rescue Timeout::Error => e
-                raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e, "Timeout writing: #{e}")
-              rescue Net::HTTPClientException => e
-                if e.response.code == "404"
-                  raise Chef::ChefFS::FileSystem::NotFoundError.new(self, e)
-                else
-                  raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e, "HTTP error writing: #{e}")
-                end
+
+              rest.put("#{api_path}/#{permission}", { permission => acls[permission] })
+            rescue Timeout::Error => e
+              raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e, "Timeout writing: #{e}")
+            rescue Net::HTTPClientException => e
+              if e.response.code == "404"
+                raise Chef::ChefFS::FileSystem::NotFoundError.new(self, e)
+              else
+                raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, e, "HTTP error writing: #{e}")
               end
+
             end
           end
         end

data/lib/chef/chef_fs/file_system/chef_server/organization_invites_entry.rb

@@ -44,15 +44,15 @@ class Chef
             actual_invites = _read_json.inject({}) { |h, val| h[val["username"]] = val["id"]; h }
             invites = actual_invites.keys
             (desired_invites - invites).each do |invite|
-              begin
-                rest.post(api_path, { "user" => invite })
-              rescue Net::HTTPClientException => e
-                if e.response.code == "409"
-                  Chef::Log.warn("Could not invite #{invite} to organization #{org}: #{api_error_text(e.response)}")
-                else
-                  raise
-                end
+
+              rest.post(api_path, { "user" => invite })
+            rescue Net::HTTPClientException => e
+              if e.response.code == "409"
+                Chef::Log.warn("Could not invite #{invite} to organization #{org}: #{api_error_text(e.response)}")
+              else
+                raise
               end
+
             end
             (invites - desired_invites).each do |invite|
               rest.delete(File.join(api_path, actual_invites[invite]))

data/lib/chef/chef_fs/file_system/chef_server/organization_members_entry.rb

@@ -43,15 +43,15 @@ class Chef
             desired_members = minimize_value(Chef::JSONCompat.parse(contents, create_additions: false))
             members = minimize_value(_read_json)
             (desired_members - members).each do |member|
-              begin
-                rest.post(api_path, "username" => member)
-              rescue Net::HTTPClientException => e
-                if %w{404 405}.include?(e.response.code)
-                  raise "Chef server at #{api_path} does not allow you to directly add members.  Please either upgrade your Chef server or move the users you want into invitations.json instead of members.json."
-                else
-                  raise
-                end
+
+              rest.post(api_path, "username" => member)
+            rescue Net::HTTPClientException => e
+              if %w{404 405}.include?(e.response.code)
+                raise "Chef server at #{api_path} does not allow you to directly add members.  Please either upgrade your Chef server or move the users you want into invitations.json instead of members.json."
+              else
+                raise
               end
+
             end
             (members - desired_members).each do |member|
               rest.delete(File.join(api_path, member))