knife 17.2.38 → 17.4.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c59d8d9f4d2b9c07749f19f302a444f81c8e4f18c1a9d975664339f491ab6a10
-  data.tar.gz: b66856e635b5af7e45ba80af0d2f9f6e13736ba8000dd82d1953864f20be9640
+  metadata.gz: 5bce1fdf8a026140f71d734c579f29ac19eeb68da7965ebc5426cdad7c00eb51
+  data.tar.gz: b10eafb114347dec04f3e1f0aaf0c1a9d9806ba2f76cfad8b57c1065e72bb0b9
 SHA512:
-  metadata.gz: 5825020630a1925537d2bf81c504f46e2370f4c6895668ff4b482fe8d16f6b0970bf8b4e93cd560f11d2a14ff68ddd5c125fcd232a8d7e312f5de05327722105
-  data.tar.gz: 4655fd4e97b9bfcf06609063a6f58cbe2fac3c8f1f73d61c7890e74dfe15480f4fd9f01a9543776f8019087f55afa52433347283239001bc20ef18a4da7d331a
+  metadata.gz: 4a5df15d3687dddd23e0469fb170fd2ea6325ee186378f98a334f7a1d42757195d2dc541ff9b370b624f949a0ab06de11d607b2029559788f0a1e406b0d8ac8d
+  data.tar.gz: 24414b3f673ae91d6c837c3b3c8740cf60746dc337c770b752fa1baf65f1773510ea9a8c72ee19e2979d70688ca1810a502afbe43092c321ae0cc1dceb8a8e69

data/Gemfile

@@ -17,10 +17,10 @@ group(:omnibus_package, :pry) do
 end
 
 group(:chefstyle) do
-  gem "chefstyle", git: "https://github.com/chef/chefstyle.git", branch: "master"
+  gem "chefstyle", git: "https://github.com/chef/chefstyle.git", branch: "main"
 end
 
-gem "ohai", git: "https://github.com/chef/ohai.git", branch: "master"
+gem "ohai", git: "https://github.com/chef/ohai.git", branch: "main"
 gem "chef", path: ".."
 gem "chef-utils", path: File.expand_path("../chef-utils", __dir__) if File.exist?(File.expand_path("../chef-utils", __dir__))
 gem "chef-config", path: File.expand_path("../chef-config", __dir__) if File.exist?(File.expand_path("../chef-config", __dir__))

data/knife.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |s|
   s.add_dependency "net-ssh-multi", "~> 1.2", ">= 1.2.1"
   s.add_dependency "ed25519", "~> 1.2" # ed25519 ssh key support
   s.add_dependency "bcrypt_pbkdf", "~> 1.1" # ed25519 ssh key support
-  s.add_dependency "x25519" # ed25519 KEX module
+  s.add_dependency "x25519", ">= 1.0.9" # ed25519 KEX module. 1.0.9+ required to resolve sigill failures
   s.add_dependency "highline", ">= 1.6.9", "< 3" # Used in UI to present a list, no other usage.
 
   s.add_dependency "tty-prompt", "~> 0.21" # knife ui.ask prompt
@@ -51,7 +51,7 @@ Gem::Specification.new do |s|
 
   s.metadata = {
     "bug_tracker_uri"   => "https://github.com/chef/chef/issues",
-    "changelog_uri"     => "https://github.com/chef/chef/blob/master/CHANGELOG.md",
+    "changelog_uri"     => "https://github.com/chef/chef/blob/main/CHANGELOG.md",
     "documentation_uri" => "https://docs.chef.io/",
     "homepage_uri"      => "https://www.chef.io",
     "mailing_list_uri"  => "https://discourse.chef.io/",

data/lib/chef/knife/bootstrap/train_connector.rb

@@ -240,7 +240,7 @@ class Chef
 
           # Now that everything is populated, fill in anything missing
           # that may be found in user ssh config
-          opts.merge!(missing_opts_from_ssh_config(opts, opts_in))
+          opts.merge!(missing_opts_from_ssh_config(opts))
 
           Train.target_config(opts)
         end
@@ -297,12 +297,12 @@ class Chef
         # in the configuration passed in.
         # This is necessary because train will default these values
         # itself - causing SSH config data to be ignored
-        def missing_opts_from_ssh_config(config, opts_in)
+        def missing_opts_from_ssh_config(config)
           return {} unless config[:backend] == "ssh"
 
           host_cfg = ssh_config_for_host(config[:host])
           opts_out = {}
-          opts_in.each do |key, _value|
+          host_cfg.each do |key, _value|
             if SSH_CONFIG_OVERRIDE_KEYS.include?(key) && !config.key?(key)
               opts_out[key] = host_cfg[key]
             end

data/lib/chef/knife/bootstrap.rb

@@ -20,6 +20,7 @@ require_relative "../knife"
 require_relative "data_bag_secret_options"
 require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 require "license_acceptance/cli_flags/mixlib_cli"
+
 module LicenseAcceptance
   autoload :Acceptor, "license_acceptance/acceptor"
 end
@@ -705,6 +706,8 @@ class Chef
           ui.warn("#{e.message} - trying with pty request")
           conn_options[:pty] = true # ensure we can talk to systems with requiretty set true in sshd config
           retry
+        elsif e.reason == :sudo_missing_terminal
+          ui.error "Sudo password is required for this operation. Please enter password using -P or --ssh-password option"
         elsif config[:use_sudo_password] && (e.reason == :sudo_password_required || e.reason == :bad_sudo_password) && limit < 3
           ui.warn("Failed to authenticate #{conn_options[:user]} to #{server_name} - #{e.message} \n sudo: #{limit} incorrect password attempt")
           sudo_password = ui.ask("Enter sudo password for #{conn_options[:user]}@#{server_name}:", echo: false)

data/lib/chef/knife/client_create.rb

@@ -54,6 +54,10 @@ class Chef
         @client_field ||= Chef::ApiClientV1.new
       end
 
+      def file
+        config[:file]
+      end
+
       def create_client(client)
         # should not be using save :( bad behavior
         Chef::ApiClientV1.from_hash(client).save
@@ -81,6 +85,8 @@ class Chef
           client.public_key File.read(File.expand_path(config[:public_key]))
         end
 
+        file_is_writable!
+
         output = edit_hash(client)
         final_client = create_client(output)
         ui.info("Created #{final_client}")
@@ -96,6 +102,39 @@ class Chef
           end
         end
       end
+
+      #
+      # This method is used to verify that the file and it's containing
+      # directory are writable.  This ensures that you don't create the client
+      # and then lose the private key because you weren't able to write it to
+      # disk.
+      #
+      # @return [void]
+      #
+      def file_is_writable!
+        return unless file
+
+        dir = File.dirname(File.expand_path(file))
+        unless File.exist?(dir)
+          ui.fatal "Directory #{dir} does not exist. Please create and retry."
+          exit 1
+        end
+
+        unless File.directory?(dir)
+          ui.fatal "#{dir} exists, but is not a directory. Please update your file path (--file #{file}) or re-create #{dir} as a directory."
+          exit 1
+        end
+
+        unless File.writable?(dir)
+          ui.fatal "Directory #{dir} is not writable. Please check the permissions."
+          exit 1
+        end
+
+        if File.exist?(file) && !File.writable?(file)
+          ui.fatal "File #{file} is not writable. Please check the permissions."
+          exit 1
+        end
+      end
     end
   end
 end

data/lib/chef/knife/cookbook_upload.rb

@@ -71,6 +71,11 @@ class Chef
         long: "--include-dependencies",
         description: "Also upload cookbook dependencies."
 
+      option :check_dependencies,
+        boolean: true, long: "--[no-]check-dependencies",
+        description: "Whether or not cookbook dependencies are verified before uploading cookbook(s) to #{ChefUtils::Dist::Server::PRODUCT}. You shouldn't disable this unless you really know what you're doing.",
+        default: true
+
       def run
         # Sanity check before we load anything from the server
         if ! config[:all] && @name_args.empty?
@@ -86,11 +91,6 @@ class Chef
         upload_failures = 0
         upload_ok = 0
 
-        # Get a list of cookbooks and their versions from the server
-        # to check for the existence of a cookbook's dependencies.
-        @server_side_cookbooks = Chef::CookbookVersion.list_all_versions
-        justify_width = @server_side_cookbooks.map(&:size).max.to_i + 2
-
         cookbooks = []
         cookbooks_to_upload.each do |cookbook_name, cookbook|
           raise Chef::Exceptions::MetadataNotFound.new(cookbook.root_paths[0], cookbook_name) unless cookbook.has_metadata_file?
@@ -120,7 +120,7 @@ class Chef
             if config[:all]
               if cookbooks_for_upload.any?
                 begin
-                  upload(cookbooks_for_upload, justify_width)
+                  upload(cookbooks_for_upload)
                 rescue Chef::Exceptions::CookbookFrozen
                   ui.warn("Not updating version constraints for some cookbooks in the environment as the cookbook is frozen.")
                   ui.error("Uploading of some of the cookbooks must be failed. Remove cookbook whose version is frozen from your cookbooks repo OR use --force option.")
@@ -133,7 +133,7 @@ class Chef
             else
               tmp_cl.each do |cookbook_name, cookbook|
 
-                upload([cookbook], justify_width)
+                upload([cookbook])
                 upload_ok += 1
               rescue Exceptions::CookbookNotFoundInRepo => e
                 upload_failures += 1
@@ -165,6 +165,27 @@ class Chef
         end
       end
 
+      def server_side_cookbooks
+        @server_side_cookbooks ||= Chef::CookbookVersion.list_all_versions
+      end
+
+      def justify_width
+        @justify_width ||= server_side_cookbooks.map(&:size).max.to_i + 2
+      end
+
+      #
+      # @param cookbook [Chef::CookbookVersion]
+      #
+      def left_justify_name(cookbook)
+        # We only want to lookup justify width value if we're already loading
+        # cookbooks to check dependencies exist in Chef Infra Server.
+        if config[:check_dependencies] == true
+          cookbook.name.to_s.ljust(justify_width + 10)
+        else
+          cookbook.name.to_s.ljust(24)
+        end
+      end
+
       def cookbooks_to_upload
         @cookbooks_to_upload ||=
           if config[:all]
@@ -220,11 +241,11 @@ class Chef
         end
       end
 
-      def upload(cookbooks, justify_width)
+      def upload(cookbooks)
         cookbooks.each do |cb|
-          ui.info("Uploading #{cb.name.to_s.ljust(justify_width + 10)} [#{cb.version}]")
+          ui.info("Uploading #{left_justify_name(cb)} [#{cb.version}]")
           check_for_broken_links!(cb)
-          check_for_dependencies!(cb)
+          check_for_dependencies!(cb) if config[:check_dependencies] == true
         end
         Chef::CookbookUploader.new(cookbooks, force: config[:force], concurrency: config[:concurrency]).upload_cookbooks
       rescue Chef::Exceptions::CookbookFrozen => e
@@ -265,12 +286,12 @@ class Chef
       end
 
       def check_server_side_cookbooks(cookbook_name, version)
-        if @server_side_cookbooks[cookbook_name].nil?
+        if server_side_cookbooks[cookbook_name].nil?
           false
         else
-          versions = @server_side_cookbooks[cookbook_name]["versions"].collect { |versions| versions["version"] }
+          versions = server_side_cookbooks[cookbook_name]["versions"].collect { |versions| versions["version"] }
           Log.debug "Versions of cookbook '#{cookbook_name}' returned by the server: #{versions.join(", ")}"
-          @server_side_cookbooks[cookbook_name]["versions"].each do |versions_hash|
+          server_side_cookbooks[cookbook_name]["versions"].each do |versions_hash|
             if Chef::VersionConstraint.new(version).include?(versions_hash["version"])
               Log.debug "Matched cookbook '#{cookbook_name}' with constraint '#{version}' to cookbook version '#{versions_hash["version"]}' on the server"
               return true

data/lib/chef/knife/core/bootstrap_context.rb

@@ -171,12 +171,12 @@ class Chef
             client_rb << "fips true\n"
           end
 
-          unless chef_config[:file_cache_path].nil?
-            client_rb << "file_cache_path \"#{chef_config[:file_cache_path]}\"\n"
+          unless chef_config[:unix_bootstrap_file_cache_path].nil?
+            client_rb << "file_cache_path \"#{chef_config[:unix_bootstrap_file_cache_path]}\"\n"
           end
 
-          unless chef_config[:file_backup_path].nil?
-            client_rb << "file_backup_path \"#{chef_config[:file_backup_path]}\"\n"
+          unless chef_config[:unix_bootstrap_file_backup_path].nil?
+            client_rb << "file_backup_path \"#{chef_config[:unix_bootstrap_file_backup_path]}\"\n"
           end
 
           client_rb

data/lib/chef/knife/core/windows_bootstrap_context.rb

@@ -71,8 +71,8 @@ class Chef
           client_rb = <<~CONFIG
             chef_server_url  "#{chef_config[:chef_server_url]}"
             validation_client_name "#{chef_config[:validation_client_name]}"
-            file_cache_path   "#{ChefConfig::PathHelper.escapepath(ChefConfig::Config.var_chef_dir(windows: true))}\\\\cache"
-            file_backup_path  "#{ChefConfig::PathHelper.escapepath(ChefConfig::Config.var_chef_dir(windows: true))}\\\\backup"
+            file_cache_path   "#{ChefConfig::PathHelper.escapepath(chef_config[:windows_bootstrap_file_cache_path] || "")}"
+            file_backup_path  "#{ChefConfig::PathHelper.escapepath(chef_config[:windows_bootstrap_file_backup_path] || "")}"
             cache_options     ({:path => "#{ChefConfig::PathHelper.escapepath(ChefConfig::Config.etc_chef_dir(windows: true))}\\\\cache\\\\checksums", :skip_expires => true})
           CONFIG
 
@@ -86,8 +86,8 @@ class Chef
             client_rb << "# Using default node name (fqdn)\n"
           end
 
-          if config[:config_log_level]
-            client_rb << %Q{log_level :#{config[:config_log_level]}\n}
+          if chef_config[:config_log_level]
+            client_rb << %Q{log_level :#{chef_config[:config_log_level]}\n}
           else
             client_rb << "log_level        :auto\n"
           end

data/lib/chef/knife/ssh.rb

@@ -134,6 +134,18 @@ class Chef
         boolean: true,
         default: false
 
+      option :pty,
+        long: "--[no-]pty",
+        description: "Request a PTY, enabled by default.",
+        boolean: true,
+        default: true
+
+      option :require_pty,
+        long: "--[no-]require-pty",
+        description: "Raise exception if a PTY cannot be acquired, disabled by default.",
+        boolean: true,
+        default: false
+
       def session
         ssh_error_handler = Proc.new do |server|
           if config[:on_error]
@@ -353,26 +365,26 @@ class Chef
         ui.msg(str)
       end
 
-      def ssh_command(command, subsession = nil)
+      # @param command [String] the command to run
+      # @param session_list [???] list of sessions, one per node
+      #
+      def ssh_command(command, session_list = session)
+        stderr = ""
         exit_status = 0
-        subsession ||= session
         command = fixup_sudo(command)
         command.force_encoding("binary") if command.respond_to?(:force_encoding)
-        begin
-          open_session(subsession, command)
-        rescue => e
-          open_session(subsession, command, true)
-        end
-      end
-
-      def open_session(subsession, command, pty = false)
-        stderr = ""
-        exit_status = 0
-        subsession.open_channel do |chan|
+        session_list.open_channel do |chan|
           if config[:on_error] && exit_status != 0
             chan.close
           else
-            chan.request_pty if pty
+            if config[:pty]
+              chan.request_pty do |ch, success|
+                unless success
+                  ui.warn("Failed to obtain a PTY from #{ch.connection.host}")
+                  raise ArgumentError, "Request for PTY failed" if config[:require_pty]
+                end
+              end
+            end
             chan.exec command do |ch, success|
               raise ArgumentError, "Cannot execute #{command}" unless success
 
@@ -383,13 +395,11 @@ class Chef
                   ichannel.send_data("#{get_password}\n")
                 end
               end
-
               ch.on_extended_data do |_, _type, data|
-                raise ArgumentError if data.eql?("sudo: no tty present and no askpass program specified\n")
+                raise ArgumentError, "No PTY present. If a PTY is required use --require-pty" if data.eql?("sudo: no tty present and no askpass program specified\n")
 
                 stderr += data
               end
-
               ch.on_request "exit-status" do |ichannel, data|
                 exit_status = [exit_status, data.read_long].max
               end
@@ -398,6 +408,8 @@ class Chef
         end
         session.loop
         exit_status
+      ensure
+        session_list.close
       end
 
       def get_password

data/lib/chef/knife/supermarket_unshare.rb

@@ -50,7 +50,8 @@ class Chef
         rescue Net::HTTPClientException => e
           raise e unless /Forbidden/.match?(e.message)
 
-          ui.error "Forbidden: You must be the maintainer of #{@cookbook_name} to unshare it."
+          ui.error "Forbidden: You must be the maintainer of #{@cookbook_name} to unshare it & #{config[:supermarket_site]} must allow maintainers to unshare cookbooks."
+          ui.warn "The default supermarket #{default_config[:supermarket_site]} does not allow maintainers to unshare cookbooks."
           exit 1
         end
 

data/lib/chef/knife/version.rb

@@ -17,7 +17,7 @@
 class Chef
   class Knife
     KNIFE_ROOT = File.expand_path("../..", __dir__)
-    VERSION = "17.2.38".freeze
+    VERSION = "17.4.46".freeze
   end
 end
 

data/spec/integration/cookbook_download_spec.rb

@@ -66,7 +66,7 @@ describe "knife cookbook download", :workstation do
         Downloading root_files
         Cookbook downloaded to #{tmpdir}/x-1.0.1
       EOM
-                                                                            )
+      )
     end
   end
 end

data/spec/unit/knife/bootstrap_spec.rb

@@ -1307,7 +1307,7 @@ describe Chef::Knife::Bootstrap do
       context "when no identity file is specified" do
         it "generates the expected configuration (no keys, keys_only false)" do
           expect(knife.ssh_identity_opts).to eq( {
-            key_files: [ ],
+            key_files: [],
             keys_only: false,
           })
         end
@@ -2050,6 +2050,19 @@ describe Chef::Knife::Bootstrap do
         expect { knife.do_connect({}) }.to raise_error(expected_error)
       end
     end
+
+    context "when a train sudo error is thrown for missing terminal" do
+      let(:ui_error_msg) { "Sudo password is required for this operation. Please enter password using -P or --ssh-password option" }
+      let(:expected_error) { Train::UserError.new(ui_error_msg, :sudo_missing_terminal) }
+      before do
+        allow(connection).to receive(:connect!).and_raise(expected_error)
+      end
+      it "outputs user friendly error message" do
+        expect { knife.do_connect({}) }.not_to raise_error
+        expect(stderr.string).to include(ui_error_msg)
+      end
+    end
+
   end
 
   describe "validate_winrm_transport_opts!" do

data/spec/unit/knife/client_create_spec.rb

@@ -54,6 +54,19 @@ describe Chef::Knife::ClientCreate do
     Chef::Config[:node_name] = "webmonkey.example.com"
   end
 
+  let(:tmpdir) { Dir.mktmpdir }
+  let(:file_path) { File.join(tmpdir, "client.pem") }
+  let(:dir_path) { File.dirname(file_path) }
+
+  before do
+    allow(File).to receive(:exist?).and_call_original
+    allow(File).to receive(:exist?).with(file_path).and_return(false)
+    allow(File).to receive(:exist?).with(dir_path).and_return(true)
+    allow(File).to receive(:directory?).with(dir_path).and_return(true)
+    allow(File).to receive(:writable?).with(file_path).and_return(true)
+    allow(File).to receive(:writable?).with(dir_path).and_return(true)
+  end
+
   describe "run" do
     context "when nothing is passed" do
       # from spec/support/shared/unit/knife_shared.rb
@@ -118,16 +131,66 @@ describe Chef::Knife::ClientCreate do
 
       describe "with -f or --file" do
         before do
+          knife.config[:file] = file_path
           client.private_key "woot"
         end
 
         it "should write the private key to a file" do
-          knife.config[:file] = "/tmp/monkeypants"
           filehandle = double("Filehandle")
           expect(filehandle).to receive(:print).with("woot")
-          expect(File).to receive(:open).with("/tmp/monkeypants", "w").and_yield(filehandle)
+          expect(File).to receive(:open).with(file_path, "w").and_yield(filehandle)
           knife.run
         end
+
+        context "when the directory does not exist" do
+          before { allow(File).to receive(:exist?).with(dir_path).and_return(false) }
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("Directory #{dir_path} does not exist. Please create and retry.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
+
+        context "when the directory is not writable" do
+          before { allow(File).to receive(:writable?).with(dir_path).and_return(false) }
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("Directory #{dir_path} is not writable. Please check the permissions.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
+
+        context "when the directory is a file" do
+          before { allow(File).to receive(:directory?).with(dir_path).and_return(false) }
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("#{dir_path} exists, but is not a directory. Please update your file path (--file #{file_path}) or re-create #{dir_path} as a directory.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
+
+        context "when the file does not exist" do
+          before do
+            allow(File).to receive(:exist?).with(file_path).and_return(false)
+          end
+
+          it "does not log a fatal message and does not raise exception" do
+            expect(knife.ui).not_to receive(:fatal)
+            expect { knife.run }.not_to raise_error
+          end
+        end
+
+        context "when the file exists and is not writable" do
+          before do
+            allow(File).to receive(:exist?).with(file_path).and_return(true)
+            allow(File).to receive(:writable?).with(file_path).and_return(false)
+          end
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("File #{file_path} is not writable. Please check the permissions.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
       end
 
       describe "with -p or --public-key" do

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -60,11 +60,12 @@ describe Chef::Knife::CookbookUpload do
   before(:each) do
     allow(Chef::CookbookLoader).to receive(:new).and_return(cookbook_loader)
     allow(Chef::CookbookLoader).to receive(:copy_to_tmp_dir_from_array).and_yield(cookbook_loader)
+    allow(Chef::CookbookVersion).to receive(:list).and_return({})
+    allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
   end
 
   describe "with --concurrency" do
     it "should upload cookbooks with predefined concurrency" do
-      allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
       knife.config[:concurrency] = 3
       test_cookbook = Chef::CookbookVersion.new("test_cookbook", "/tmp/blah")
       allow(cookbook_loader).to receive(:each).and_yield("test_cookbook", test_cookbook)
@@ -79,7 +80,6 @@ describe Chef::Knife::CookbookUpload do
   describe "run" do
     before(:each) do
       allow(Chef::CookbookUploader).to receive_messages(new: cookbook_uploader)
-      allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
     end
 
     it "should print usage and exit when a cookbook name is not provided" do
@@ -214,48 +214,110 @@ describe Chef::Knife::CookbookUpload do
       end
     end
 
-    describe "when specifying a cookbook name with missing dependencies" do
-      let(:cookbook_dependency) { Chef::CookbookVersion.new("dependency", "/tmp/blah") }
+    context "when chef_dependencies config is disabled" do
+      before do
+        knife.config[:check_dependencies] = false
+      end
 
-      before(:each) do
-        cookbook.metadata.depends("dependency")
-        allow(cookbook_loader).to receive(:[]) do |ckbk|
-          { "test_cookbook" => cookbook,
-            "dependency" => cookbook_dependency }[ckbk]
+      describe "when specifying a cookbook name with missing dependencies" do
+        let(:cookbook_dependency) { Chef::CookbookVersion.new("dependency", "/tmp/blah") }
+
+        before(:each) do
+          cookbook.metadata.depends("dependency")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{cookbook_dependency test_cookbook})
+          @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+          knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
         end
-        allow(knife).to receive(:cookbook_names).and_return(%w{cookbook_dependency test_cookbook})
-        @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
-        knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
-      end
 
-      it "should exit and not upload the cookbook" do
-        expect(cookbook_loader).to receive(:[]).once.with("test_cookbook")
-        expect(cookbook_uploader).not_to receive(:upload_cookbooks)
-        expect { knife.run }.to raise_error(SystemExit)
+        it "should not fetch all cookbooks from Chef Infra Server" do
+          expect(Chef::CookbookVersion).not_to receive(:list_all_versions)
+          knife.run
+        end
+
+        it "should upload the cookbook" do
+          expect(cookbook_loader).to receive(:[]).once.with("test_cookbook")
+          expect(cookbook_uploader).to receive(:upload_cookbooks)
+          knife.run
+        end
+
+        it "should not output a message for a single missing dependency" do
+          knife.run
+          expect(@stderr.string).not_to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).not_to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).not_to include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+        end
+
+        it "should not output a message for a multiple missing dependencies which are concatenated" do
+          cookbook_dependency2 = Chef::CookbookVersion.new("dependency2")
+          cookbook.metadata.depends("dependency2")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency,
+              "dependency2" => cookbook_dependency2 }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{dependency dependency2 test_cookbook})
+          knife.run
+          expect(@stderr.string).not_to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).not_to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).not_to include("The missing cookbook(s) are:")
+          expect(@stderr.string).not_to include("'dependency' version '>= 0.0.0'")
+          expect(@stderr.string).not_to include("'dependency2' version '>= 0.0.0'")
+        end
       end
+    end
 
-      it "should output a message for a single missing dependency" do
-        expect { knife.run }.to raise_error(SystemExit)
-        expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
-        expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
-        expect(@stderr.string).to include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+    context "when chef_dependencies config is enabled" do
+      before do
+        knife.config[:check_dependencies] = true
       end
 
-      it "should output a message for a multiple missing dependencies which are concatenated" do
-        cookbook_dependency2 = Chef::CookbookVersion.new("dependency2")
-        cookbook.metadata.depends("dependency2")
-        allow(cookbook_loader).to receive(:[]) do |ckbk|
-          { "test_cookbook" => cookbook,
-            "dependency" => cookbook_dependency,
-            "dependency2" => cookbook_dependency2 }[ckbk]
+      describe "when specifying a cookbook name with missing dependencies" do
+        let(:cookbook_dependency) { Chef::CookbookVersion.new("dependency", "/tmp/blah") }
+
+        before(:each) do
+          cookbook.metadata.depends("dependency")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{cookbook_dependency test_cookbook})
+          @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+          knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
+        end
+
+        it "should exit and not upload the cookbook" do
+          expect(cookbook_loader).to receive(:[]).once.with("test_cookbook")
+          expect(cookbook_uploader).not_to receive(:upload_cookbooks)
+          expect { knife.run }.to raise_error(SystemExit)
+        end
+
+        it "should output a message for a single missing dependency" do
+          expect { knife.run }.to raise_error(SystemExit)
+          expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).to include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+        end
+
+        it "should output a message for a multiple missing dependencies which are concatenated" do
+          cookbook_dependency2 = Chef::CookbookVersion.new("dependency2")
+          cookbook.metadata.depends("dependency2")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency,
+              "dependency2" => cookbook_dependency2 }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{dependency dependency2 test_cookbook})
+          expect { knife.run }.to raise_error(SystemExit)
+          expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).to include("The missing cookbook(s) are:")
+          expect(@stderr.string).to include("'dependency' version '>= 0.0.0'")
+          expect(@stderr.string).to include("'dependency2' version '>= 0.0.0'")
         end
-        allow(knife).to receive(:cookbook_names).and_return(%w{dependency dependency2 test_cookbook})
-        expect { knife.run }.to raise_error(SystemExit)
-        expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
-        expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
-        expect(@stderr.string).to include("The missing cookbook(s) are:")
-        expect(@stderr.string).to include("'dependency' version '>= 0.0.0'")
-        expect(@stderr.string).to include("'dependency2' version '>= 0.0.0'")
       end
     end
 

data/spec/unit/knife/core/bootstrap_context_spec.rb

@@ -80,16 +80,16 @@ describe Chef::Knife::Core::BootstrapContext do
     end
   end
 
-  describe "when file_cache_path is set" do
-    let(:chef_config) { { file_cache_path: "/home/opscode/cache" } }
-    it "sets file_cache_path in the generated config file" do
+  describe "when unix_bootstrap_file_cache_path is set" do
+    let(:chef_config) { { unix_bootstrap_file_cache_path: "/home/opscode/cache" } }
+    it "sets unix_bootstrap_file_cache_path in the generated config file" do
       expect(bootstrap_context.config_content).to include("file_cache_path \"/home/opscode/cache\"")
     end
   end
 
-  describe "when file_backup_path is set" do
-    let(:chef_config) { { file_backup_path: "/home/opscode/backup" } }
-    it "sets file_backup_path in the generated config file" do
+  describe "when unix_bootstrap_file_backup_path is set" do
+    let(:chef_config) { { unix_bootstrap_file_backup_path: "/home/opscode/backup" } }
+    it "sets unix_bootstrap_file_backup_path in the generated config file" do
       expect(bootstrap_context.config_content).to include("file_backup_path \"/home/opscode/backup\"")
     end
   end

data/spec/unit/knife/core/windows_bootstrap_context_spec.rb

@@ -154,8 +154,8 @@ describe Chef::Knife::Core::WindowsBootstrapContext do
           config_log_location: STDOUT,
           chef_server_url: "http://chef.example.com:4444",
           validation_client_name: "chef-validator-testing",
-          file_cache_path: "c:/chef/cache",
-          file_backup_path: "c:/chef/backup",
+          windows_bootstrap_file_cache_path: "c:/chef/cache",
+          windows_bootstrap_file_backup_path: "c:/chef/backup",
           cache_options: ({ path: "c:/chef/cache/checksums", skip_expires: true })
         )
       )
@@ -165,11 +165,11 @@ describe Chef::Knife::Core::WindowsBootstrapContext do
       expected = <<~EXPECTED
         echo.chef_server_url  "http://chef.example.com:4444"
         echo.validation_client_name "chef-validator-testing"
-        echo.file_cache_path   "C:\\\\chef\\\\cache"
-        echo.file_backup_path  "C:\\\\chef\\\\backup"
+        echo.file_cache_path   "c:/chef/cache"
+        echo.file_backup_path  "c:/chef/backup"
         echo.cache_options     ^({:path =^> "C:\\\\chef\\\\cache\\\\checksums", :skip_expires =^> true}^)
         echo.# Using default node name ^(fqdn^)
-        echo.log_level        :auto
+        echo.log_level :info
         echo.log_location       STDOUT
       EXPECTED
       expect(bootstrap_context.config_content).to eq expected

data/spec/unit/knife/ssh_spec.rb

@@ -289,7 +289,7 @@ describe Chef::Knife::Ssh do
     let(:execution_channel2) { double(:execution_channel, on_data: nil, on_extended_data: nil) }
     let(:session_channel2) { double(:session_channel, request_pty: nil) }
 
-    let(:session) { double(:session, loop: nil) }
+    let(:session) { double(:session, loop: nil, close: nil) }
 
     let(:command) { "false" }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife
 version: !ruby/object:Gem::Version
-  version: 17.2.38
+  version: 17.4.46
 platform: ruby
 authors:
 - Adam Jacob
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-15 00:00:00.000000000 Z
+date: 2021-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-config
@@ -262,14 +262,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.9
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
@@ -765,6 +765,7 @@ files:
 - spec/data/kitchen/openldap/recipes/woot.rb
 - spec/data/knife-home/.chef/plugins/knife/example_home_subcommand.rb
 - spec/data/knife-site-subcommands/plugins/knife/example_subcommand.rb
+- spec/data/knife/temp_dir/tmp.pem
 - spec/data/knife_subcommand/test_explicit_category.rb
 - spec/data/knife_subcommand/test_name_mapping.rb
 - spec/data/knife_subcommand/test_yourself.rb
@@ -1143,7 +1144,7 @@ licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/chef/chef/issues
-  changelog_uri: https://github.com/chef/chef/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/chef/chef/blob/main/CHANGELOG.md
   documentation_uri: https://docs.chef.io/
   homepage_uri: https://www.chef.io
   mailing_list_uri: https://discourse.chef.io/
@@ -1163,7 +1164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: The knife CLI for Chef Infra.