chef 12.13.37 → 12.14.60

data/lib/chef/http/auth_credentials.rb

@@ -49,7 +49,7 @@ class Chef
 
         sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(request_params)
         signed = sign_obj.sign(key).merge({ :host => host })
-        signed.inject({}) { |memo, kv| memo["#{kv[0].to_s.upcase}"] = kv[1];memo }
+        signed.inject({}) { |memo, kv| memo["#{kv[0].to_s.upcase}"] = kv[1]; memo }
       end
 
     end

data/lib/chef/http/basic_client.rb

@@ -34,6 +34,7 @@ class Chef
       attr_reader :url
       attr_reader :http_client
       attr_reader :ssl_policy
+      attr_reader :keepalives
 
       # Instantiate a BasicClient.
       # === Arguments:
@@ -43,7 +44,11 @@ class Chef
       def initialize(url, opts = {})
         @url = url
         @ssl_policy = opts[:ssl_policy] || DefaultSSLPolicy
-        @http_client = build_http_client
+        @keepalives = opts[:keepalives] || false
+      end
+
+      def http_client
+        @http_client ||= build_http_client
       end
 
       def host
@@ -114,7 +119,11 @@ class Chef
 
         http_client.read_timeout = config[:rest_timeout]
         http_client.open_timeout = config[:rest_timeout]
-        http_client
+        if keepalives
+          http_client.start
+        else
+          http_client
+        end
       end
 
       def config

data/lib/chef/http/socketless_chef_zero_client.rb

@@ -197,9 +197,9 @@ class Chef
       private
 
       def headers_extracted_from_options
-        options.reject { |name, _| KNOWN_OPTIONS.include?(name) }.map { |name, value|
+        options.reject { |name, _| KNOWN_OPTIONS.include?(name) }.map do |name, value|
           [name.to_s.split("_").map { |segment| segment.capitalize }.join("-"), value]
-        }
+        end
       end
 
     end

data/lib/chef/key.rb

@@ -201,72 +201,71 @@ class Chef
       chef_rest.delete("#{api_base}/#{@actor}/keys/#{@name}")
     end
 
-    # Class methods
-    def self.from_hash(key_hash)
-      if key_hash.has_key?("user")
-        key = Chef::Key.new(key_hash["user"], "user")
-      elsif key_hash.has_key?("client")
-        key = Chef::Key.new(key_hash["client"], "client")
-      else
-        raise Chef::Exceptions::MissingKeyAttribute, "The hash passed to from_hash does not contain the key 'user' or 'client'. Please pass a hash that defines one of those keys."
+    class << self
+      def from_hash(key_hash)
+        if key_hash.has_key?("user")
+          key = Chef::Key.new(key_hash["user"], "user")
+        elsif key_hash.has_key?("client")
+          key = Chef::Key.new(key_hash["client"], "client")
+        else
+          raise Chef::Exceptions::MissingKeyAttribute, "The hash passed to from_hash does not contain the key 'user' or 'client'. Please pass a hash that defines one of those keys."
+        end
+        key.name key_hash["name"] if key_hash.key?("name")
+        key.public_key key_hash["public_key"] if key_hash.key?("public_key")
+        key.private_key key_hash["private_key"] if key_hash.key?("private_key")
+        key.create_key key_hash["create_key"] if key_hash.key?("create_key")
+        key.expiration_date key_hash["expiration_date"] if key_hash.key?("expiration_date")
+        key
       end
-      key.name key_hash["name"] if key_hash.key?("name")
-      key.public_key key_hash["public_key"] if key_hash.key?("public_key")
-      key.private_key key_hash["private_key"] if key_hash.key?("private_key")
-      key.create_key key_hash["create_key"] if key_hash.key?("create_key")
-      key.expiration_date key_hash["expiration_date"] if key_hash.key?("expiration_date")
-      key
-    end
-
-    def self.from_json(json)
-      Chef::Key.from_hash(Chef::JSONCompat.from_json(json))
-    end
 
-    def self.json_create(json)
-      Chef.log_deprecation("Auto inflation of JSON data is deprecated. Please use Chef::Key#from_json or one of the load_by methods.")
-      Chef::Key.from_json(json)
-    end
+      def from_json(json)
+        Chef::Key.from_hash(Chef::JSONCompat.from_json(json))
+      end
 
-    def self.list_by_user(actor, inflate = false)
-      keys = Chef::ServerAPI.new(Chef::Config[:chef_server_root]).get("users/#{actor}/keys")
-      self.list(keys, actor, :load_by_user, inflate)
-    end
+      def json_create(json)
+        Chef.log_deprecation("Auto inflation of JSON data is deprecated. Please use Chef::Key#from_json or one of the load_by methods.")
+        Chef::Key.from_json(json)
+      end
 
-    def self.list_by_client(actor, inflate = false)
-      keys = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("clients/#{actor}/keys")
-      self.list(keys, actor, :load_by_client, inflate)
-    end
+      def list_by_user(actor, inflate = false)
+        keys = Chef::ServerAPI.new(Chef::Config[:chef_server_root]).get("users/#{actor}/keys")
+        self.list(keys, actor, :load_by_user, inflate)
+      end
 
-    def self.load_by_user(actor, key_name)
-      response = Chef::ServerAPI.new(Chef::Config[:chef_server_root]).get("users/#{actor}/keys/#{key_name}")
-      Chef::Key.from_hash(response.merge({ "user" => actor }))
-    end
+      def list_by_client(actor, inflate = false)
+        keys = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("clients/#{actor}/keys")
+        self.list(keys, actor, :load_by_client, inflate)
+      end
 
-    def self.load_by_client(actor, key_name)
-      response = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("clients/#{actor}/keys/#{key_name}")
-      Chef::Key.from_hash(response.merge({ "client" => actor }))
-    end
+      def load_by_user(actor, key_name)
+        response = Chef::ServerAPI.new(Chef::Config[:chef_server_root]).get("users/#{actor}/keys/#{key_name}")
+        Chef::Key.from_hash(response.merge({ "user" => actor }))
+      end
 
-    def self.generate_fingerprint(public_key)
-      openssl_key_object = OpenSSL::PKey::RSA.new(public_key)
-      data_string = OpenSSL::ASN1::Sequence([
-                                              OpenSSL::ASN1::Integer.new(openssl_key_object.public_key.n),
-                                              OpenSSL::ASN1::Integer.new(openssl_key_object.public_key.e),
-                                            ])
-      OpenSSL::Digest::SHA1.hexdigest(data_string.to_der).scan(/../).join(":")
-    end
+      def load_by_client(actor, key_name)
+        response = Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("clients/#{actor}/keys/#{key_name}")
+        Chef::Key.from_hash(response.merge({ "client" => actor }))
+      end
 
-    private
+      def generate_fingerprint(public_key)
+        openssl_key_object = OpenSSL::PKey::RSA.new(public_key)
+        data_string = OpenSSL::ASN1::Sequence([
+          OpenSSL::ASN1::Integer.new(openssl_key_object.public_key.n),
+          OpenSSL::ASN1::Integer.new(openssl_key_object.public_key.e),
+        ])
+        OpenSSL::Digest::SHA1.hexdigest(data_string.to_der).scan(/../).join(":")
+      end
 
-    def self.list(keys, actor, load_method_symbol, inflate)
-      if inflate
-        keys.inject({}) do |key_map, result|
-          name = result["name"]
-          key_map[name] = Chef::Key.send(load_method_symbol, actor, name)
-          key_map
+      def list(keys, actor, load_method_symbol, inflate)
+        if inflate
+          keys.inject({}) do |key_map, result|
+            name = result["name"]
+            key_map[name] = Chef::Key.send(load_method_symbol, actor, name)
+            key_map
+          end
+        else
+          keys
         end
-      else
-        keys
       end
     end
   end

data/lib/chef/knife.rb

@@ -233,61 +233,66 @@ class Chef
       end
     end
 
-    private
-
     OFFICIAL_PLUGINS = %w{ec2 rackspace windows openstack terremark bluebox}
 
-    def self.path_from_caller(caller_line)
-      caller_line.split(/:\d+/).first
-    end
-
-    # :nodoc:
-    # Error out and print usage. probably because the arguments given by the
-    # user could not be resolved to a subcommand.
-    def self.subcommand_not_found!(args)
-      ui.fatal("Cannot find subcommand for: '#{args.join(' ')}'")
+    class << self
+      private
 
-      # Mention rehash when the subcommands cache(plugin_manifest.json) is used
-      if subcommand_loader.is_a?(Chef::Knife::SubcommandLoader::HashedCommandLoader) ||
-          subcommand_loader.is_a?(Chef::Knife::SubcommandLoader::CustomManifestLoader)
-        ui.info("If this is a recently installed plugin, please run 'knife rehash' to update the subcommands cache.")
+      # @api private
+      def path_from_caller(caller_line)
+        caller_line.split(/:\d+/).first
       end
 
-      if category_commands = guess_category(args)
-        list_commands(category_commands)
-      elsif missing_plugin = ( OFFICIAL_PLUGINS.find { |plugin| plugin == args[0] } )
-        ui.info("The #{missing_plugin} commands were moved to plugins in Chef 0.10")
-        ui.info("You can install the plugin with `(sudo) gem install knife-#{missing_plugin}`")
-        ui.info("Use `chef gem install knife-#{missing_plugin}` instead if using ChefDK")
-      else
-        list_commands
-      end
+      # :nodoc:
+      # Error out and print usage. probably because the arguments given by the
+      # user could not be resolved to a subcommand.
+      # @api private
+      def subcommand_not_found!(args)
+        ui.fatal("Cannot find subcommand for: '#{args.join(' ')}'")
+
+        # Mention rehash when the subcommands cache(plugin_manifest.json) is used
+        if subcommand_loader.is_a?(Chef::Knife::SubcommandLoader::HashedCommandLoader) ||
+            subcommand_loader.is_a?(Chef::Knife::SubcommandLoader::CustomManifestLoader)
+          ui.info("If this is a recently installed plugin, please run 'knife rehash' to update the subcommands cache.")
+        end
 
-      exit 10
-    end
+        if category_commands = guess_category(args)
+          list_commands(category_commands)
+        elsif missing_plugin = ( OFFICIAL_PLUGINS.find { |plugin| plugin == args[0] } )
+          ui.info("The #{missing_plugin} commands were moved to plugins in Chef 0.10")
+          ui.info("You can install the plugin with `(sudo) gem install knife-#{missing_plugin}`")
+          ui.info("Use `chef gem install knife-#{missing_plugin}` instead if using ChefDK")
+        else
+          list_commands
+        end
+
+        exit 10
+      end
 
-    def self.list_commands(preferred_category = nil)
-      category_desc = preferred_category ? preferred_category + " " : ""
-      msg "Available #{category_desc}subcommands: (for details, knife SUB-COMMAND --help)\n\n"
-      subcommand_loader.list_commands(preferred_category).sort.each do |category, commands|
-        next if category =~ /deprecated/i
-        msg "** #{category.upcase} COMMANDS **"
-        commands.sort.each do |command|
-          subcommand_loader.load_command(command)
-          msg subcommands[command].banner if subcommands[command]
+      # @api private
+      def list_commands(preferred_category = nil)
+        category_desc = preferred_category ? preferred_category + " " : ""
+        msg "Available #{category_desc}subcommands: (for details, knife SUB-COMMAND --help)\n\n"
+        subcommand_loader.list_commands(preferred_category).sort.each do |category, commands|
+          next if category =~ /deprecated/i
+          msg "** #{category.upcase} COMMANDS **"
+          commands.sort.each do |command|
+            subcommand_loader.load_command(command)
+            msg subcommands[command].banner if subcommands[command]
+          end
+          msg
         end
-        msg
       end
-    end
 
-    def self.reset_config_path!
-      @@chef_config_dir = nil
+      # @api private
+      def reset_config_path!
+        @@chef_config_dir = nil
+      end
+
     end
 
     reset_config_path!
 
-    public
-
     # Create a new instance of the current class configured for the given
     # arguments and options
     def initialize(argv = [])
@@ -324,31 +329,35 @@ class Chef
       exit(1)
     end
 
-    # Returns a subset of the Chef::Config[:knife] Hash that is relevant to the
-    # currently executing knife command. This is used by #configure_chef to
-    # apply settings from knife.rb to the +config+ hash.
+    # keys from mixlib-cli options
+    def cli_keys
+      self.class.options.keys
+    end
+
+    # extracts the settings from the Chef::Config[:knife] sub-hash that correspond
+    # to knife cli options -- in preparation for merging config values with cli values
+    #
+    # NOTE: due to weirdness in mixlib-config #has_key? is only true if the value has
+    # been set by the user -- the Chef::Config defaults return #has_key?() of false and
+    # this code DEPENDS on that functionality since applying the default values in
+    # Chef::Config[:knife] would break the defaults in the cli that we would otherwise
+    # overwrite.
     def config_file_settings
-      config_file_settings = {}
-      self.class.options.keys.each do |key|
-        config_file_settings[key] = Chef::Config[:knife][key] if Chef::Config[:knife].has_key?(key)
+      cli_keys.each_with_object({}) do |key, memo|
+        memo[key] = Chef::Config[:knife][key] if Chef::Config[:knife].has_key?(key)
       end
-      config_file_settings
     end
 
-    # Apply Config in this order:
-    # defaults from mixlib-cli
-    # settings from config file, via Chef::Config[:knife]
-    # config from command line
+    # config is merged in this order (inverse of precedence)
+    #  default_config       - mixlib-cli defaults (accessor from the mixin)
+    #  config_file_settings - Chef::Config[:knife] sub-hash
+    #  config               - mixlib-cli settings (accessor from the mixin)
     def merge_configs
-      # Apply config file settings on top of mixlib-cli defaults
-      combined_config = default_config.merge(config_file_settings)
-      # Apply user-supplied options on top of the above combination
-      combined_config = combined_config.merge(config)
-      # replace the config hash from mixlib-cli with our own.
-      # Need to use the mutate-in-place #replace method instead of assigning to
-      # the instance variable because other code may have a reference to the
-      # original config hash object.
-      config.replace(combined_config)
+      # other code may have a handle to the config object, so use Hash#replace to deliberately
+      # update-in-place.
+      config.replace(
+        default_config.merge(config_file_settings).merge(config)
+      )
     end
 
     # Catch-all method that does any massaging needed for various config

data/lib/chef/knife/client_delete.rb

@@ -43,7 +43,7 @@ class Chef
           exit 1
         end
 
-        delete_object(Chef::ApiClientV1, @client_name, "client") {
+        delete_object(Chef::ApiClientV1, @client_name, "client") do
           object = Chef::ApiClientV1.load(@client_name)
           if object.validator
             unless config[:delete_validators]
@@ -52,7 +52,7 @@ class Chef
             end
           end
           object.destroy
-        }
+        end
       end
 
     end

data/lib/chef/knife/cookbook_bulk_delete.rb

@@ -42,7 +42,7 @@ class Chef
 
         all_cookbooks = Chef::CookbookVersion.list
         cookbooks_names = all_cookbooks.keys.grep(regex)
-        cookbooks_to_delete = cookbooks_names.inject({}) { |hash, name| hash[name] = all_cookbooks[name];hash }
+        cookbooks_to_delete = cookbooks_names.inject({}) { |hash, name| hash[name] = all_cookbooks[name]; hash }
         ui.msg "All versions of the following cookbooks will be deleted:"
         ui.msg ""
         ui.msg ui.list(cookbooks_to_delete.keys.sort, :columns_down)

data/lib/chef/knife/cookbook_show.rb

@@ -63,7 +63,7 @@ class Chef
           node[:platform_version] = config[:platform_version] if config.has_key?(:platform_version)
 
           class << node
-            def attribute?(name)
+            def attribute?(name) # rubocop:disable Lint/NestedMethodDefinition
               has_key?(name)
             end
           end

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

@@ -81,9 +81,9 @@ class Chef
           files = []
 
           if check_load_path
-            files = $LOAD_PATH.map { |load_path|
+            files = $LOAD_PATH.map do |load_path|
               Dir["#{File.expand_path glob, Chef::Util::PathHelper.escape_glob_dir(load_path)}#{Gem.suffix_pattern}"]
-            }.flatten.select { |file| File.file? file.untaint }
+            end.flatten.select { |file| File.file? file.untaint }
           end
 
           gem_files = latest_gem_specs.map do |spec|
@@ -110,7 +110,7 @@ class Chef
         end
 
         def check_spec_for_glob(spec, glob)
-          dirs = if spec.require_paths.size > 1 then
+          dirs = if spec.require_paths.size > 1
                    "{#{spec.require_paths.join(',')}}"
                  else
                    spec.require_paths.first

data/lib/chef/knife/search.rb

@@ -18,6 +18,7 @@
 
 require "chef/knife"
 require "chef/knife/core/node_presenter"
+require "addressable/uri"
 
 class Chef
   class Knife
@@ -85,8 +86,7 @@ class Chef
         end
 
         q = Chef::Search::Query.new
-        escaped_query = URI.escape(@query,
-                           Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+        escaped_query = Addressable::URI.encode_component(@query, Addressable::URI::CharacterClasses::QUERY)
 
         result_items = []
         result_count = 0

data/lib/chef/knife/ssh.rb

@@ -164,9 +164,7 @@ class Chef
       end
 
       def configure_session
-        list = config[:manual] ?
-               @name_args[0].split(" ") :
-               search_nodes
+        list = config[:manual] ? @name_args[0].split(" ") : search_nodes
         if list.length == 0
           if @action_nodes.length == 0
             ui.fatal("No nodes returned from search")
@@ -548,24 +546,24 @@ class Chef
         configure_session
 
         exit_status =
-        case @name_args[1]
-        when "interactive"
-          interactive
-        when "screen"
-          screen
-        when "tmux"
-          tmux
-        when "macterm"
-          macterm
-        when "cssh"
-          cssh
-        when "csshx"
-          Chef::Log.warn("knife ssh csshx will be deprecated in a future release")
-          Chef::Log.warn("please use knife ssh cssh instead")
-          cssh
-        else
-          ssh_command(@name_args[1..-1].join(" "))
-        end
+          case @name_args[1]
+          when "interactive"
+            interactive
+          when "screen"
+            screen
+          when "tmux"
+            tmux
+          when "macterm"
+            macterm
+          when "cssh"
+            cssh
+          when "csshx"
+            Chef::Log.warn("knife ssh csshx will be deprecated in a future release")
+            Chef::Log.warn("please use knife ssh cssh instead")
+            cssh
+          else
+            ssh_command(@name_args[1..-1].join(" "))
+          end
 
         session.close
         if exit_status != 0