chef 16.3.38-universal-mingw32 → 16.5.64-universal-mingw32

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))

data/lib/chef/chef_fs/file_system/repository/chef_repository_file_system_cookbook_dir.rb

@@ -76,7 +76,7 @@ class Chef
 
             # Write out .uploaded-cookbook-version.json
             # cookbook_file_path = File.join(file_path, cookbook_name) <- this should be the same as self.file_path
-            unless File.exists?(file_path)
+            unless File.exist?(file_path)
               FileUtils.mkdir_p(file_path)
             end
             uploaded_cookbook_version_path = File.join(file_path, Chef::Cookbook::CookbookVersionLoader::UPLOADED_COOKBOOK_VERSION_FILE)
@@ -132,7 +132,7 @@ class Chef
           end
 
           def can_upload?
-            File.exists?(uploaded_cookbook_version_path) || children.size > 0
+            File.exist?(uploaded_cookbook_version_path) || children.size > 0
           end
 
           protected

data/lib/chef/chef_fs/file_system/repository/chef_repository_file_system_cookbook_entry.rb

@@ -137,7 +137,7 @@ class Chef
           end
 
           def exists?
-            File.exists?(file_path) && (parent.nil? || parent.can_have_child?(name, dir?))
+            File.exist?(file_path) && (parent.nil? || parent.can_have_child?(name, dir?))
           end
 
           def read

data/lib/chef/chef_fs/file_system/repository/chef_repository_file_system_root_dir.rb

@@ -109,23 +109,23 @@ class Chef
               child = root_dir.create_child(name, file_contents)
             else
               child_paths[name].each do |path|
-                begin
-                  ::FileUtils.mkdir_p(path)
-                  ::FileUtils.chmod(0700, path)
-                  if ChefUtils.windows?
-                    all_mask = Chef::ReservedNames::Win32::API::Security::GENERIC_ALL
-                    administrators = Chef::ReservedNames::Win32::Security::SID.Administrators
-                    owner = Chef::ReservedNames::Win32::Security::SID.default_security_object_owner
-                    dacl = Chef::ReservedNames::Win32::Security::ACL.create([
-                      Chef::ReservedNames::Win32::Security::ACE.access_allowed(owner, all_mask),
-                      Chef::ReservedNames::Win32::Security::ACE.access_allowed(administrators, all_mask),
-                    ])
-                    so = Chef::ReservedNames::Win32::Security::SecurableObject.new(path)
-                    so.owner = owner
-                    so.set_dacl(dacl, false)
-                  end
-                rescue Errno::EEXIST
+
+                ::FileUtils.mkdir_p(path)
+                ::FileUtils.chmod(0700, path)
+                if ChefUtils.windows?
+                  all_mask = Chef::ReservedNames::Win32::API::Security::GENERIC_ALL
+                  administrators = Chef::ReservedNames::Win32::Security::SID.Administrators
+                  owner = Chef::ReservedNames::Win32::Security::SID.default_security_object_owner
+                  dacl = Chef::ReservedNames::Win32::Security::ACL.create([
+                    Chef::ReservedNames::Win32::Security::ACE.access_allowed(owner, all_mask),
+                    Chef::ReservedNames::Win32::Security::ACE.access_allowed(administrators, all_mask),
+                  ])
+                  so = Chef::ReservedNames::Win32::Security::SecurableObject.new(path)
+                  so.owner = owner
+                  so.set_dacl(dacl, false)
                 end
+              rescue Errno::EEXIST
+
               end
               child = make_child_entry(name)
             end
@@ -161,7 +161,7 @@ class Chef
           # members.json and org.json may be found.
           #
           def root_dir
-            existing_paths = root_paths.select { |path| File.exists?(path) }
+            existing_paths = root_paths.select { |path| File.exist?(path) }
             if existing_paths.size > 0
               MultiplexedDir.new(existing_paths.map do |path|
                 dir = FileSystemEntry.new(name, parent, path)
@@ -184,7 +184,7 @@ class Chef
               return root_dir.child(name)
             end
 
-            paths = (child_paths[name] || []).select { |path| File.exists?(path) }
+            paths = (child_paths[name] || []).select { |path| File.exist?(path) }
             if paths.size == 0
               return NonexistentFSObject.new(name, self)
             end

data/lib/chef/chef_fs/file_system/repository/directory.rb

@@ -151,7 +151,7 @@ class Chef
           end
 
           def exists?
-            File.exists?(file_path)
+            File.exist?(file_path)
           end
 
           protected

data/lib/chef/chef_fs/file_system/repository/file_system_entry.rb

@@ -122,7 +122,7 @@ class Chef
           end
 
           def exists?
-            File.exists?(file_path) && (parent.nil? || parent.can_have_child?(name, dir?))
+            File.exist?(file_path) && (parent.nil? || parent.can_have_child?(name, dir?))
           end
 
           def read

data/lib/chef/chef_fs/knife.rb

@@ -18,7 +18,7 @@
 
 require_relative "../knife"
 require "pathname" unless defined?(Pathname)
-require_relative "../dist"
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 class Chef
   module ChefFS
@@ -49,7 +49,7 @@ class Chef
 
       option :chef_repo_path,
         long: "--chef-repo-path PATH",
-        description: "Overrides the location of #{Chef::Dist::PRODUCT} repo. Default is specified by chef_repo_path in the config"
+        description: "Overrides the location of #{ChefUtils::Dist::Infra::PRODUCT} repo. Default is specified by chef_repo_path in the config"
 
       option :concurrency,
         long: "--concurrency THREADS",

data/lib/chef/chef_fs/parallelizer.rb

@@ -1,4 +1,3 @@
-require "thread"
 require_relative "parallelizer/parallel_enumerable"
 
 class Chef

data/lib/chef/client.rb

@@ -29,7 +29,7 @@ require_relative "api_client/registration"
 require_relative "node"
 require_relative "role"
 require_relative "file_cache"
-require_relative "run_context"
+Chef.autoload :RunContext, File.expand_path("run_context", __dir__)
 require_relative "runner"
 require_relative "run_status"
 require_relative "cookbook/cookbook_collection"
@@ -48,14 +48,13 @@ require_relative "action_collection"
 require_relative "resource_reporter"
 require_relative "data_collector"
 require_relative "run_lock"
-require_relative "policy_builder"
+Chef.autoload :PolicyBuilder, File.expand_path("policy_builder", __dir__)
 require_relative "request_id"
 require_relative "platform/rebooter"
 require_relative "mixin/deprecation"
 require "chef-utils" unless defined?(ChefUtils::CANARY)
 require "ohai" unless defined?(Ohai::System)
-require "rbconfig"
-require_relative "dist"
+require "rbconfig" unless defined?(RbConfig)
 require "forwardable" unless defined?(Forwardable)
 
 class Chef
@@ -245,11 +244,11 @@ class Chef
 
         events.run_start(Chef::VERSION, run_status)
 
-        logger.info("*** #{Chef::Dist::PRODUCT} #{Chef::VERSION} ***")
+        logger.info("*** #{ChefUtils::Dist::Infra::PRODUCT} #{Chef::VERSION} ***")
         logger.info("Platform: #{RUBY_PLATFORM}")
-        logger.info "#{Chef::Dist::CLIENT.capitalize} pid: #{Process.pid}"
+        logger.info "#{ChefUtils::Dist::Infra::CLIENT.capitalize} pid: #{Process.pid}"
         logger.info "Targeting node: #{Chef::Config.target_mode.host}" if Chef::Config.target_mode?
-        logger.debug("#{Chef::Dist::CLIENT.capitalize} request_id: #{request_id}")
+        logger.debug("#{ChefUtils::Dist::Infra::CLIENT.capitalize} request_id: #{request_id}")
         ENV["PATH"] = ChefUtils::DSL::DefaultPaths.default_paths if Chef::Config[:enforce_default_paths] || Chef::Config[:enforce_path_sanity]
 
         if Chef::Config.target_mode?
@@ -273,7 +272,7 @@ class Chef
         build_node
 
         run_status.start_clock
-        logger.info("Starting #{Chef::Dist::PRODUCT} Run for #{node.name}")
+        logger.info("Starting #{ChefUtils::Dist::Infra::PRODUCT} Run for #{node.name}")
         run_started
 
         do_windows_admin_check
@@ -288,7 +287,7 @@ class Chef
         converge_and_save(run_context)
 
         run_status.stop_clock
-        logger.info("#{Chef::Dist::PRODUCT} Run complete in #{run_status.elapsed_time} seconds")
+        logger.info("#{ChefUtils::Dist::Infra::PRODUCT} Run complete in #{run_status.elapsed_time} seconds")
         run_completed_successfully
         events.run_completed(node, run_status)
 
@@ -334,7 +333,7 @@ class Chef
       eol_year = 2006 + Gem::Version.new(Chef::VERSION).segments.first
 
       if Time.now > Time.new(eol_year, 5, 01)
-        logger.warn("This release of #{Chef::Dist::PRODUCT} became end of life (EOL) on May 1st #{eol_year}. Please update to a supported release to receive new features, bug fixes, and security updates.")
+        logger.warn("This release of #{ChefUtils::Dist::Infra::PRODUCT} became end of life (EOL) on May 1st #{eol_year}. Please update to a supported release to receive new features, bug fixes, and security updates.")
       end
     end
 
@@ -707,16 +706,16 @@ class Chef
     #
     def converge(run_context)
       catch(:end_client_run_early) do
-        begin
-          events.converge_start(run_context)
-          logger.debug("Converging node #{node_name}")
-          @runner = Chef::Runner.new(run_context)
-          @runner.converge
-          events.converge_complete
-        rescue Exception => e
-          events.converge_failed(e)
-          raise e
-        end
+
+        events.converge_start(run_context)
+        logger.debug("Converging node #{node_name}")
+        @runner = Chef::Runner.new(run_context)
+        @runner.converge
+        events.converge_complete
+      rescue Exception => e
+        events.converge_failed(e)
+        raise e
+
       end
     end
 
@@ -763,7 +762,7 @@ class Chef
         logger.trace("Checking for administrator privileges....")
 
         if !has_admin_privileges?
-          message = "#{Chef::Dist::CLIENT} doesn't have administrator privileges on node #{node_name}."
+          message = "#{ChefUtils::Dist::Infra::CLIENT} doesn't have administrator privileges on node #{node_name}."
           if Chef::Config[:fatal_windows_admin_check]
             logger.fatal(message)
             logger.fatal("fatal_windows_admin_check is set to TRUE.")
@@ -772,7 +771,7 @@ class Chef
             logger.warn("#{message} This might cause unexpected resource failures.")
           end
         else
-          logger.trace("#{Chef::Dist::CLIENT} has administrator privileges on node #{node_name}.")
+          logger.trace("#{ChefUtils::Dist::Infra::CLIENT} has administrator privileges on node #{node_name}.")
         end
       end
     end

data/lib/chef/cookbook/cookbook_version_loader.rb

@@ -17,7 +17,7 @@ require_relative "../cookbook_version"
 require_relative "chefignore"
 require_relative "metadata"
 require_relative "../util/path_helper"
-require "find"
+require "find" unless defined?(Find.find)
 
 class Chef
   class Cookbook

data/lib/chef/cookbook/synchronizer.rb

@@ -17,7 +17,7 @@ require_relative "../client"
 require_relative "../util/threaded_job_queue"
 require_relative "../server_api"
 require "singleton" unless defined?(Singleton)
-require_relative "../dist"
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 class Chef
 
@@ -65,7 +65,7 @@ class Chef
         # manifest.
         cache.find(File.join(%w{cookbooks ** {*,.*}})).each do |cache_filename|
           unless @valid_cache_entries[cache_filename]
-            Chef::Log.info("Removing #{cache_filename} from the cache; it is no longer needed by #{Chef::Dist::CLIENT}.")
+            Chef::Log.info("Removing #{cache_filename} from the cache; it is no longer needed by #{ChefUtils::Dist::Infra::CLIENT}.")
             cache.delete(cache_filename)
           end
         end

data/lib/chef/cookbook_site_streaming_uploader.rb

@@ -18,11 +18,17 @@
 # limitations under the License.
 #
 
-require "uri" unless defined?(URI)
-require "net/http" unless defined?(Net::HTTP)
-require "mixlib/authentication/signedheaderauth"
-require "openssl" unless defined?(OpenSSL)
-require_relative "dist"
+autoload :URI, "uri"
+module Net
+  autoload :HTTP, File.expand_path("monkey_patches/net_http", __dir__)
+end
+autoload :OpenSSL, "openssl"
+module Mixlib
+  module Authentication
+    autoload :SignedHeaderAuth, "mixlib/authentication/signedheaderauth"
+  end
+end
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 class Chef
   # == Chef::CookbookSiteStreamingUploader
@@ -37,7 +43,7 @@ class Chef
     class << self
 
       def create_build_dir(cookbook)
-        tmp_cookbook_path = Tempfile.new("#{Chef::Dist::SHORT}-#{cookbook.name}-build")
+        tmp_cookbook_path = Tempfile.new("#{ChefUtils::Dist::Infra::SHORT}-#{cookbook.name}-build")
         tmp_cookbook_path.close
         tmp_cookbook_dir = tmp_cookbook_path.path
         File.unlink(tmp_cookbook_dir)
@@ -225,11 +231,7 @@ class Chef
           @part_no += 1
           @part_offset = 0
           next_part = read(how_much_next_part)
-          result = current_part + if next_part
-                                    next_part
-                                  else
-                                    ""
-                                  end
+          result = current_part + (next_part || "")
         else
           @part_offset += how_much_current_part
           result = current_part

data/lib/chef/cookbook_uploader.rb

@@ -1,5 +1,5 @@
 
-require "set" unless defined?(Set)
+autoload :Set, "set"
 require_relative "exceptions"
 require_relative "knife/cookbook_metadata"
 require_relative "digester"

data/lib/chef/data_collector.rb

@@ -21,12 +21,12 @@
 require_relative "server_api"
 require_relative "http/simple_json"
 require_relative "event_dispatch/base"
-require "set" unless defined?(Set)
+autoload :Set, "set"
 require_relative "data_collector/run_end_message"
 require_relative "data_collector/run_start_message"
 require_relative "data_collector/config_validation"
 require_relative "data_collector/error_handlers"
-require_relative "dist"
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 class Chef
   class DataCollector
@@ -197,7 +197,7 @@ class Chef
         else
           if code == "404"
             # Make the message non-scary for folks who don't have automate:
-            msg << " (This is normal if you do not have #{Chef::Dist::AUTOMATE})"
+            msg << " (This is normal if you do not have #{ChefUtils::Dist::Automate::PRODUCT})"
             Chef::Log.debug(msg)
           else
             Chef::Log.warn(msg)
@@ -212,8 +212,9 @@ class Chef
       def send_to_output_locations(message)
         return unless Chef::Config[:data_collector][:output_locations]
 
+        Chef::DataCollector::ConfigValidation.validate_output_locations!
         Chef::Config[:data_collector][:output_locations].each do |type, locations|
-          locations.each do |location|
+          Array(locations).each do |location|
             send_to_file_location(location, message) if type == :files
             send_to_http_location(location, message) if type == :urls
           end
@@ -226,7 +227,7 @@ class Chef
       # @param message [Hash] the message to render as JSON
       #
       def send_to_file_location(file_name, message)
-        File.open(file_name, "a") do |fh|
+        File.open(File.expand_path(file_name), "a") do |fh|
           fh.puts Chef::JSONCompat.to_json(message, validate_utf8: false)
         end
       end

data/lib/chef/data_collector/config_validation.rb

@@ -16,6 +16,7 @@
 #
 
 require "uri" unless defined?(URI)
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 class Chef
   class DataCollector
@@ -46,14 +47,14 @@ class Chef
           return unless output_locations
 
           # but deliberately setting an empty output_location we consider to be an error (XXX: but should we?)
-          if output_locations.empty?
+          unless valid_hash_with_keys?(output_locations, :urls, :files)
             raise Chef::Exceptions::ConfigurationError,
               "Chef::Config[:data_collector][:output_locations] is empty. Please supply an hash of valid URLs and / or local file paths."
           end
 
           # loop through all the types and locations and validate each one-by-one
           output_locations.each do |type, locations|
-            locations.each do |location|
+            Array(locations).each do |location|
               validate_url!(location) if type == :urls
               validate_file!(location) if type == :files
             end
@@ -86,15 +87,20 @@ class Chef
             false
           when running_mode == :client && Chef::Config[:data_collector][:token]
             Chef::Log.warn("Data collector token authentication is not recommended for client-server mode. " \
-                           "Please upgrade #{Chef::Dist::SERVER_PRODUCT} to 12.11 or later and remove the token from your config file " \
+                           "Please upgrade #{ChefUtils::Dist::Server::PRODUCT} to 12.11 or later and remove the token from your config file " \
                            "to use key based authentication instead")
             true
-          when Chef::Config[:data_collector][:output_locations] && Chef::Config[:data_collector][:output_locations][:files] && !Chef::Config[:data_collector][:output_locations][:files].empty?
+          when Chef::Config[:data_collector][:output_locations] && !valid_hash_with_keys?(Chef::Config[:data_collector][:output_locations], :urls)
             # we can run fine to a file without a token, even in solo mode.
+            unless valid_hash_with_keys?(Chef::Config[:data_collector][:output_locations], :files)
+              raise Chef::Exceptions::ConfigurationError,
+                "Chef::Config[:data_collector][:output_locations] is empty. Please supply an hash of valid URLs and / or local file paths."
+            end
+
             true
           when running_mode == :solo && !Chef::Config[:data_collector][:token]
             # we are in solo mode and are not logging to a file, so must have a token
-            Chef::Log.trace("Data collector token must be configured to use #{Chef::Dist::AUTOMATE} data collector with #{Chef::Dist::SOLO}")
+            Chef::Log.trace("Data collector token must be configured to use #{ChefUtils::Dist::Automate::PRODUCT} data collector with #{ChefUtils::Dist::Solo::PRODUCT}")
             false
           else
             true
@@ -105,16 +111,10 @@ class Chef
 
         # validate an output_location file
         def validate_file!(file)
-          open(file, "a") {}
-        rescue Errno::ENOENT
+          return true if Chef::Config.path_accessible?(File.expand_path(file))
+
           raise Chef::Exceptions::ConfigurationError,
             "Chef::Config[:data_collector][:output_locations][:files] contains the location #{file}, which is a non existent file path."
-        rescue Errno::EACCES
-          raise Chef::Exceptions::ConfigurationError,
-            "Chef::Config[:data_collector][:output_locations][:files] contains the location #{file}, which cannot be written to by Chef."
-        rescue Exception => e
-          raise Chef::Exceptions::ConfigurationError,
-            "Chef::Config[:data_collector][:output_locations][:files] contains the location #{file}, which is invalid: #{e.message}."
         end
 
         # validate an output_location url
@@ -125,6 +125,15 @@ class Chef
             "Chef::Config[:data_collector][:output_locations][:urls] contains the url #{url} which is not valid."
         end
 
+        # Validate the hash contains at least one of the given keys.
+        #
+        # @param hash [Hash] the hash to be validated.
+        # @param keys [Array] an array of keys to check existence of in the hash.
+        # @return [Boolean] true if the hash contains any of the given keys.
+        #
+        def valid_hash_with_keys?(hash, *keys)
+          hash.is_a?(Hash) && keys.any? { |k| hash.key?(k) }
+        end
       end
     end
   end