cheffish 14.0.13 → 16.0.8

data/lib/chef/resource/chef_organization.rb

@@ -6,7 +6,7 @@ require "chef/chef_fs/data_handler/data_handler_base"
 class Chef
   class Resource
     class ChefOrganization < Cheffish::BaseResource
-      resource_name :chef_organization
+      provides :chef_organization
 
       property :organization_name, Cheffish::NAME_REGEX, name_property: true
       property :full_name, String
@@ -68,7 +68,7 @@ class Chef
           end
         end
         new_resource.members.each do |user|
-          if !existing_members.include?(user)
+          unless existing_members.include?(user)
             converge_by "Add #{user} to organization #{new_resource.organization_name}" do
               rest.post("#{rest.root_url}/organizations/#{new_resource.organization_name}/users/", { "username" => user })
             end
@@ -130,7 +130,7 @@ class Chef
       action_class.class_eval do
         def load_current_resource
           @current_resource = json_to_resource(rest.get("#{rest.root_url}/organizations/#{new_resource.organization_name}"))
-        rescue Net::HTTPServerException => e
+        rescue Net::HTTPClientException => e
           if e.response.code == "404"
             @current_resource = not_found_resource
           else

data/lib/chef/resource/chef_resolved_cookbooks.rb

@@ -4,7 +4,7 @@ require "chef_zero"
 class Chef
   class Resource
     class ChefResolvedCookbooks < Cheffish::BaseResource
-      resource_name :chef_resolved_cookbooks
+      provides :chef_resolved_cookbooks
 
       def initialize(*args)
         super
@@ -43,7 +43,8 @@ class Chef
           new_resource.berksfile.upload(
             server_url: new_resource.chef_server[:chef_server_url],
             client_name: new_resource.chef_server[:options][:client_name],
-            client_key: new_resource.chef_server[:options][:signing_key_filename])
+            client_key: new_resource.chef_server[:options][:signing_key_filename]
+          )
         else
           file = Tempfile.new("privatekey")
           begin
@@ -53,7 +54,8 @@ class Chef
             new_resource.berksfile.upload(
               server_url: new_resource.chef_server[:chef_server_url],
               client_name: new_resource.chef_server[:options][:client_name] || "me",
-              client_key: file.path)
+              client_key: file.path
+            )
 
           ensure
             file.close

data/lib/chef/resource/chef_role.rb

@@ -6,7 +6,7 @@ require "chef/chef_fs/data_handler/role_data_handler"
 class Chef
   class Resource
     class ChefRole < Cheffish::BaseResource
-      resource_name :chef_role
+      provides :chef_role
 
       property :role_name, Cheffish::NAME_REGEX, name_property: true
       property :description, String
@@ -62,6 +62,7 @@ class Chef
         if recipes.size == 0
           raise ArgumentError, "At least one recipe must be specified"
         end
+
         @run_list_modifiers ||= []
         @run_list_modifiers += recipes.map { |recipe| Chef::RunList::RunListItem.new("recipe[#{recipe}]") }
       end
@@ -70,6 +71,7 @@ class Chef
         if roles.size == 0
           raise ArgumentError, "At least one role must be specified"
         end
+
         @run_list_modifiers ||= []
         @run_list_modifiers += roles.map { |role| Chef::RunList::RunListItem.new("role[#{role}]") }
       end
@@ -78,6 +80,7 @@ class Chef
         if recipes.size == 0
           raise ArgumentError, "At least one recipe must be specified"
         end
+
         @run_list_removers ||= []
         @run_list_removers += recipes.map { |recipe| Chef::RunList::RunListItem.new("recipe[#{recipe}]") }
       end
@@ -86,6 +89,7 @@ class Chef
         if roles.size == 0
           raise ArgumentError, "At least one role must be specified"
         end
+
         @run_list_removers ||= []
         @run_list_removers += roles.map { |recipe| Chef::RunList::RunListItem.new("role[#{role}]") }
       end
@@ -119,7 +123,7 @@ class Chef
       action_class.class_eval do
         def load_current_resource
           @current_resource = json_to_resource(rest.get("roles/#{new_resource.role_name}"))
-        rescue Net::HTTPServerException => e
+        rescue Net::HTTPClientException => e
           if e.response.code == "404"
             @current_resource = not_found_resource
           else

data/lib/chef/resource/chef_user.rb

@@ -4,7 +4,7 @@ require_relative "../../cheffish/chef_actor_base"
 class Chef
   class Resource
     class ChefUser < Cheffish::ChefActorBase
-      resource_name :chef_user
+      provides :chef_user
 
       # Client attributes
       property :user_name, Cheffish::NAME_REGEX, name_property: true
@@ -25,7 +25,7 @@ class Chef
 
       # Output public key (if so desired)
       property :output_key_path, String
-      property :output_key_format, [ :pem, :der, :openssh ], default: :openssh
+      property :output_key_format, %i{pem der openssh}, default: :openssh
 
       # Proc that runs just before the resource executes.  Called with (resource)
       def before(&block)

data/lib/chef/resource/private_key.rb

@@ -1,23 +1,23 @@
 require "openssl/cipher"
 require_relative "../../cheffish/base_resource"
-require "openssl"
+require "openssl" unless defined?(OpenSSL)
 require_relative "../../cheffish/key_formatter"
 
 class Chef
   class Resource
     class PrivateKey < Cheffish::BaseResource
-      resource_name :private_key
+      provides :private_key
 
       allowed_actions :create, :delete, :regenerate, :nothing
       default_action :create
 
       # Path to private key.  Set to :none to create the key in memory and not on disk.
       property :path, [ String, :none ], name_property: true
-      property :format, [ :pem, :der ], default: :pem
-      property :type, [ :rsa, :dsa ], default: :rsa # TODO support :ec
+      property :format, %i{pem der}, default: :pem
+      property :type, %i{rsa dsa}, default: :rsa # TODO support :ec
       # These specify an optional public_key you can spit out if you want.
       property :public_key_path, String
-      property :public_key_format, [ :openssh, :pem, :der ], default: :openssh
+      property :public_key_format, %i{openssh pem der}, default: :openssh
       # Specify this if you want to copy another private key but give it a different format / password
       property :source_key
       property :source_key_path, String
@@ -31,7 +31,7 @@ class Chef
 
       # PEM-only
       property :pass_phrase, String
-      property :cipher, String, equal_to: OpenSSL::Cipher.ciphers.map { |x| x.downcase }, default: "des-ede3-cbc", coerce: proc { |x| x.downcase }
+      property :cipher, String, equal_to: OpenSSL::Cipher.ciphers.map(&:downcase), default: "des-ede3-cbc", coerce: proc { |x| x.downcase }
 
       # Set this to regenerate the key if it does not have the desired characteristics (like size, type, etc.)
       property :regenerate_if_different, [TrueClass, FalseClass]
@@ -202,22 +202,22 @@ class Chef
         def new_key_with_path
           path = new_resource.path
           if path.is_a?(Symbol)
-            return [ nil, path ]
+            [ nil, path ]
           elsif Pathname.new(path).relative?
             private_key, private_key_path = Cheffish.get_private_key_with_path(path, run_context.config)
             if private_key
-              return [ private_key, (private_key_path || :none) ]
+              [ private_key, (private_key_path || :none) ]
             elsif run_context.config[:private_key_write_path]
               @should_create_directory = true
               path = ::File.join(run_context.config[:private_key_write_path], path)
-              return [ nil, path ]
+              [ nil, path ]
             else
               raise "Could not find key #{path} and Chef::Config.private_key_write_path is not set."
             end
           elsif ::File.exist?(path)
-            return [ IO.read(path), path ]
+            [ IO.read(path), path ]
           else
-            return [ nil, path ]
+            [ nil, path ]
           end
         end
 

data/lib/chef/resource/public_key.rb

@@ -1,18 +1,18 @@
 require "openssl/cipher"
 require_relative "../../cheffish/base_resource"
-require "openssl"
+require "openssl" unless defined?(OpenSSL)
 require_relative "../../cheffish/key_formatter"
 
 class Chef
   class Resource
     class PublicKey < Cheffish::BaseResource
-      resource_name :public_key
+      provides :public_key
 
       allowed_actions :create, :delete, :nothing
       default_action :create
 
       property :path, String, name_property: true
-      property :format, [ :pem, :der, :openssh ], default: :openssh
+      property :format, %i{pem der openssh}, default: :openssh
 
       property :source_key
       property :source_key_path, String
@@ -24,9 +24,10 @@ class Chef
       end
 
       action :create do
-        if !new_source_key
+        unless new_source_key
           raise "No source key specified"
         end
+
         desired_output = encode_public_key(new_source_key)
         if Array(current_resource.action) == [ :delete ] || desired_output != IO.read(new_resource.path)
           converge_by "write #{new_resource.format} public key #{new_resource.path} from #{new_source_key_publicity} key #{new_resource.source_key_path}" do

data/lib/cheffish.rb

@@ -98,6 +98,7 @@ module Cheffish
     elsif config[:private_key_paths]
       config[:private_key_paths].each do |private_key_path|
         next unless File.exist?(private_key_path)
+
         Dir.entries(private_key_path).sort.each do |key|
           ext = File.extname(key)
           if key == name || ext == "" || ext == ".pem"

data/lib/cheffish/base_resource.rb

@@ -91,7 +91,7 @@ module Cheffish
       end
 
       def json_differences_internal(old_json, new_json, print_values, name, result)
-        if old_json.kind_of?(Hash) && new_json.kind_of?(Hash)
+        if old_json.is_a?(Hash) && new_json.is_a?(Hash)
           removed_keys = old_json.keys.inject({}) { |hash, key| hash[key] = true; hash }
           new_json.each_pair do |new_key, new_value|
             if old_json.key?(new_key)
@@ -101,18 +101,18 @@ module Cheffish
               end
             else
               if print_values
-                result << "  add #{name == '' ? new_key : "#{name}.#{new_key}"} = #{new_value.inspect}"
+                result << "  add #{name == "" ? new_key : "#{name}.#{new_key}"} = #{new_value.inspect}"
               else
-                result << "  add #{name == '' ? new_key : "#{name}.#{new_key}"}"
+                result << "  add #{name == "" ? new_key : "#{name}.#{new_key}"}"
               end
             end
           end
           removed_keys.keys.each do |removed_key|
-            result << "  remove #{name == '' ? removed_key : "#{name}.#{removed_key}"}"
+            result << "  remove #{name == "" ? removed_key : "#{name}.#{removed_key}"}"
           end
         else
-          old_json = old_json.to_s if old_json.kind_of?(Symbol)
-          new_json = new_json.to_s if new_json.kind_of?(Symbol)
+          old_json = old_json.to_s if old_json.is_a?(Symbol)
+          new_json = new_json.to_s if new_json.is_a?(Symbol)
           if old_json != new_json
             if print_values
               result << "  update #{name} from #{old_json.inspect} to #{new_json.inspect}"
@@ -134,8 +134,8 @@ module Cheffish
         end
 
         modifiers.each do |path, value|
-          path = [path] if !path.kind_of?(Array)
-          path = path.map { |path_part| path_part.to_s }
+          path = [path] unless path.is_a?(Array)
+          path = path.map(&:to_s)
           parent = 0.upto(path.size - 2).inject(json) do |hash, index|
             if hash.nil?
               nil
@@ -148,6 +148,7 @@ module Cheffish
           if !parent.nil? && !parent.is_a?(Hash)
             raise "Attempt to set #{path} to #{value} when #{path[0..-2]} is not a hash"
           end
+
           existing_value = parent ? parent[path[-1]] : nil
 
           if value.is_a?(Proc)
@@ -158,7 +159,7 @@ module Cheffish
           else
             # Create parent if necessary, overwriting values
             parent = path[0..-2].inject(json) do |hash, path_part|
-              hash[path_part] = {} if !hash[path_part]
+              hash[path_part] = {} unless hash[path_part]
               hash[path_part]
             end
             if path.size > 0
@@ -173,6 +174,7 @@ module Cheffish
 
       def apply_run_list_modifiers(add_to_run_list, delete_from_run_list, run_list)
         return run_list if (!add_to_run_list || add_to_run_list.size == 0) && (!delete_from_run_list || !delete_from_run_list.size)
+
         delete_from_run_list ||= []
         add_to_run_list ||= []
 
@@ -191,7 +193,7 @@ module Cheffish
             # because found_desired will be less than add_to_run_list_index.  The result will
             # be X, A, B, Y, Z.
             if found_desired >= add_to_run_list_index
-              result += add_to_run_list[add_to_run_list_index..found_desired].map { |item| item.to_s }
+              result += add_to_run_list[add_to_run_list_index..found_desired].map(&:to_s)
               add_to_run_list_index = found_desired + 1
             end
           else
@@ -204,7 +206,7 @@ module Cheffish
         end
 
         # Copy any remaining desired items at the end
-        result += add_to_run_list[add_to_run_list_index..-1].map { |item| item.to_s }
+        result += add_to_run_list[add_to_run_list_index..-1].map(&:to_s)
         result
       end
 

data/lib/cheffish/basic_chef_client.rb

@@ -5,7 +5,7 @@ require "chef/event_dispatch/dispatcher"
 require "chef/node"
 require "chef/run_context"
 require "chef/runner"
-require "forwardable"
+require "forwardable" unless defined?(Forwardable)
 require "chef/providers"
 require "chef/resources"
 
@@ -14,7 +14,7 @@ module Cheffish
     include Chef::DSL::Recipe
 
     def initialize(node = nil, events = nil, **chef_config)
-      if !node
+      unless node
         node = Chef::Node.new
         node.name "basic_chef_client"
         node.automatic[:platform] = "basic_chef_client"
@@ -31,7 +31,7 @@ module Cheffish
         case events
         when Array
           events.each { |e| dispatcher.register(e) } if events
-        when !nil
+        when !nil # rubocop: disable Lint/LiteralAsCondition
           dispatcher.register(events)
         end
         @run_context = Chef::RunContext.new(node, {}, dispatcher)
@@ -80,12 +80,11 @@ module Cheffish
     # add_resource() method.
     def self.build_resource(type, name, created_at = nil, &resource_attrs_block)
       created_at ||= caller[0]
-      result = BasicChefClient.new.tap do |client|
+      BasicChefClient.new.tap do |client|
         client.with_chef_config do
           client.build_resource(type, name, created_at, &resource_attrs_block)
         end
       end
-      result
     end
 
     def self.inline_resource(provider, provider_action, *resources, &block)

data/lib/cheffish/chef_actor_base.rb

@@ -24,9 +24,10 @@ module Cheffish
           end
         else
           # Create the actor if it's missing
-          if !new_public_key
+          unless new_public_key
             raise "You must specify a public key to create a #{actor_type}!  Use the private_key resource to create a key, and pass it in with source_key_path."
           end
+
           description = [ "create #{actor_type} #{new_resource.name} at #{actor_path}" ] + differences
           converge_by description do
             result = rest.post((actor_path).to_s, normalize_for_post(new_json))
@@ -118,7 +119,7 @@ module Cheffish
         begin
           json = rest.get("#{actor_path}/#{new_resource.name}")
           @current_resource = json_to_resource(json)
-        rescue Net::HTTPServerException => e
+        rescue Net::HTTPClientException => e
           if e.response.code == "404"
             @current_resource = not_found_resource
           else

data/lib/cheffish/chef_run.rb

@@ -34,15 +34,14 @@ module Cheffish
     def client
       @client ||= begin
         chef_config = self.chef_config.dup
-        chef_config[:log_level] ||= :debug if !chef_config.key?(:log_level)
-        chef_config[:verbose_logging] = false if !chef_config.key?(:verbose_logging)
+        chef_config[:log_level] ||= :debug unless chef_config.key?(:log_level)
+        chef_config[:verbose_logging] = false unless chef_config.key?(:verbose_logging)
         chef_config[:stdout] = StringIOTee.new(chef_config[:stdout])
         chef_config[:stderr] = StringIOTee.new(chef_config[:stderr])
         chef_config[:log_location] = StringIOTee.new(chef_config[:log_location])
         @client = ::Cheffish::BasicChefClient.new(nil,
           [ event_sink, Chef::Formatters.new(:doc, chef_config[:stdout], chef_config[:stderr]) ],
-          chef_config
-        )
+          chef_config)
       end
     end
 
@@ -125,14 +124,14 @@ module Cheffish
         message << "--- Chef Client Output ---\n"
         message << "---                    ---\n"
         message << stdout
-        message << "\n" if !stdout.end_with?("\n")
+        message << "\n" unless stdout.end_with?("\n")
       end
       if stderr && !stderr.empty?
         message << "---                          ---\n"
         message << "--- Chef Client Error Output ---\n"
         message << "---                          ---\n"
         message << stderr
-        message << "\n" if !stderr.end_with?("\n")
+        message << "\n" unless stderr.end_with?("\n")
       end
       if logs && !logs.empty?
         message << "---                  ---\n"

data/lib/cheffish/chef_run_listener.rb

@@ -21,9 +21,7 @@ module Cheffish
     def disconnect
       # Stop the servers
       if node.run_context
-        node.run_context.cheffish.local_servers.each do |server|
-          server.stop
-        end
+        node.run_context.cheffish.local_servers.each(&:stop)
       end
     end
   end

data/lib/cheffish/key_formatter.rb

@@ -1,7 +1,7 @@
-require "openssl"
-require "net/ssh"
-require "etc"
-require "socket"
+require "openssl" unless defined?(OpenSSL)
+require "net/ssh" unless defined?(Net::SSH)
+require "etc" unless defined?(Etc)
+require "socket" unless defined?(Socket)
 require "digest/md5"
 require "base64"
 
@@ -55,15 +55,7 @@ module Cheffish
         hexes = Digest::MD5.hexdigest(data)
         hexes.scan(/../).join(":")
       when :pkcs8sha1fingerprint
-        if RUBY_VERSION.to_f >= 2.0
-          raise "PKCS8 SHA1 not supported in Ruby #{RUBY_VERSION}"
-        end
-        require "openssl_pkcs8"
-        pkcs8_pem = key.to_pem_pkcs8
-        pkcs8_base64 = pkcs8_pem.split("\n").reject { |l| l =~ /^-----/ }
-        pkcs8_data = Base64.decode64(pkcs8_base64.join)
-        hexes = Digest::SHA1.hexdigest(pkcs8_data)
-        hexes.scan(/../).join(":")
+        raise "PKCS8 SHA1 not supported by Ruby 2.0 and later"
       else
         raise "Unrecognized key format #{format}"
       end