chef 12.18.31 → 12.19.33

data/lib/chef/mixin/params_validate.rb

@@ -102,8 +102,8 @@ class Chef
           when Hash
             validation.each do |check, carg|
               check_method = "_pv_#{check}"
-              if self.respond_to?(check_method, true)
-                self.send(check_method, opts, key, carg)
+              if respond_to?(check_method, true)
+                send(check_method, opts, key, carg)
               else
                 raise ArgumentError, "Validation map has unknown check: #{check}"
               end
@@ -333,7 +333,7 @@ class Chef
         if is_name_property
           if opts[key].nil?
             raise CannotValidateStaticallyError, "name_property cannot be evaluated without a resource." if self == Chef::Mixin::ParamsValidate
-            opts[key] = self.instance_variable_get(:"@name")
+            opts[key] = instance_variable_get(:"@name")
           end
         end
       end

data/lib/chef/mixin/securable.rb

@@ -110,7 +110,7 @@ class Chef
           # equivalent to something like:
           # def rights(permissions=nil, principals=nil, args_hash=nil)
           define_method(name) do |permissions = nil, principals = nil, args_hash = nil|
-            rights = self.instance_variable_get("@#{name}".to_sym)
+            rights = instance_variable_get("@#{name}".to_sym)
             unless permissions.nil?
               input = {
                 :permissions => permissions,

data/lib/chef/mixin/shell_out.rb

@@ -1,6 +1,6 @@
 #--
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# Copyright:: Copyright 2010-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,6 +16,7 @@
 # limitations under the License.
 
 require "mixlib/shellout"
+require "chef/deprecated"
 
 class Chef
   module Mixin
@@ -75,6 +76,24 @@ class Chef
         end
       end
 
+      # helper sugar for resources that support passing timeouts to shell_out
+
+      def shell_out_compact_timeout(*args, **options)
+        raise "object is not a resource that supports timeouts" unless respond_to?(:new_resource) && new_resource.respond_to?(:timeout)
+        options_dup = options.dup
+        options_dup[:timeout] = new_resource.timeout if new_resource.timeout
+        options_dup[:timeout] = 900 unless options_dup.key?(:timeout)
+        shell_out_compact(*args, **options_dup)
+      end
+
+      def shell_out_compact_timeout!(*args, **options)
+        raise "object is not a resource that supports timeouts" unless respond_to?(:new_resource) && new_resource.respond_to?(:timeout)
+        options_dup = options.dup
+        options_dup[:timeout] = new_resource.timeout if new_resource.timeout
+        options_dup[:timeout] = 900 unless options_dup.key?(:timeout)
+        shell_out_compact!(*args, **options_dup)
+      end
+
       # shell_out! runs a command on the system and will raise an error if the command fails, which is what you want
       # for debugging, shell_out and shell_out! both will display command output to the tty when the log level is debug
       # Generally speaking, 'extend Chef::Mixin::ShellOut' in your recipes and include 'Chef::Mixin::ShellOut' in your LWRPs
@@ -129,7 +148,7 @@ class Chef
           my_options[new_option] = value
         end
 
-        return my_command_args
+        my_command_args
       end
 
       # Helper for sublcasses to convert an array of string args into a string.  It
@@ -139,7 +158,8 @@ class Chef
       # @param args [String] variable number of string arguments
       # @return [String] nicely concatenated string or empty string
       def a_to_s(*args)
-        # FIXME: this should be deprecated in favor of shell_out_compact/shell_out_compact!
+        # can't quite deprecate this yet
+        #Chef.deprecated(:package_misc, "a_to_s is deprecated use shell_out_compact or shell_out_compact_timeout instead")
         args.flatten.reject { |i| i.nil? || i == "" }.map(&:to_s).join(" ")
       end
 

data/lib/chef/mixin/unformatter.rb

@@ -22,9 +22,9 @@ class Chef
 
       def write(message)
         data = message.match(/(\[.+?\] )?([\w]+):(.*)$/)
-        self.send(data[2].downcase.chomp.to_sym, data[3].strip)
+        send(data[2].downcase.chomp.to_sym, data[3].strip)
       rescue NoMethodError
-        self.send(:info, message)
+        send(:info, message)
       end
 
     end

data/lib/chef/mixin/uris.rb

@@ -31,12 +31,10 @@ class Chef
       end
 
       def as_uri(source)
-        begin
-          URI.parse(source)
-        rescue URI::InvalidURIError
-          Chef::Log.warn("#{source} was an invalid URI. Trying to escape invalid characters")
-          URI.parse(Addressable::URI.encode(source))
-        end
+        URI.parse(source)
+      rescue URI::InvalidURIError
+        Chef::Log.warn("#{source} was an invalid URI. Trying to escape invalid characters")
+        URI.parse(Addressable::URI.encode(source))
       end
 
     end

data/lib/chef/mixin/versioned_api.rb

@@ -0,0 +1,69 @@
+#--
+# Copyright:: Copyright 2017, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  module Mixin
+    module VersionedAPI
+
+      def minimum_api_version(version = nil)
+        if version
+          @minimum_api_version = version
+        else
+          @minimum_api_version
+        end
+      end
+
+    end
+
+    module VersionedAPIFactory
+
+      def versioned_interfaces
+        @versioned_interfaces ||= []
+      end
+
+      def add_versioned_api_class(klass)
+        versioned_interfaces << klass
+      end
+
+      def versioned_api_class
+        versioned_interfaces.select do |klass|
+          version = klass.send(:minimum_api_version)
+          # min and max versions will be nil if we've not made a request to the server yet,
+          # in which case we'll just start with the highest version and see what happens
+          ServerAPIVersions.instance.min_server_version.nil? || (version >= ServerAPIVersions.instance.min_server_version && version <= ServerAPIVersions.instance.max_server_version)
+        end
+          .sort { |a, b| a.send(:minimum_api_version) <=> b.send(:minimum_api_version) }
+          .last
+      end
+
+      def def_versioned_delegator(method)
+        line_no = __LINE__; str = %{
+          def self.#{method}(*args, &block)
+            versioned_api_class.__send__(:#{method}, *args, &block)
+          end
+        }
+        module_eval(str, __FILE__, line_no)
+      end
+
+      def new(*args)
+        object = versioned_api_class.allocate
+        object.send(:initialize, *args)
+        object
+      end
+    end
+  end
+end

data/lib/chef/mixin/which.rb

@@ -1,6 +1,6 @@
 #--
 # Author:: Lamont Granquist <lamont@chef.io>
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# Copyright:: Copyright 2010-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,15 +18,32 @@
 class Chef
   module Mixin
     module Which
-      def which(cmd, extra_path: nil)
+      def which(*cmds, extra_path: nil, &block)
+        where(*cmds, extra_path: extra_path, &block).first || false
+      end
+
+      def where(*cmds, extra_path: nil, &block)
         # NOTE: unnecessarily duplicates function of path_sanity
         extra_path ||= [ "/bin", "/usr/bin", "/sbin", "/usr/sbin" ]
-        paths = ENV["PATH"].split(File::PATH_SEPARATOR) + extra_path
-        paths.each do |path|
-          filename = Chef.path_to(File.join(path, cmd))
-          return filename if File.executable?(filename)
-        end
-        false
+        paths = env_path.split(File::PATH_SEPARATOR) + extra_path
+        cmds.map do |cmd|
+          paths.map do |path|
+            filename = Chef.path_to(File.join(path, cmd))
+            filename if valid_executable?(filename, &block)
+          end.compact
+        end.flatten
+      end
+
+      private
+
+      # for test stubbing
+      def env_path
+        ENV["PATH"]
+      end
+
+      def valid_executable?(filename, &block)
+        return false unless File.executable?(filename) && !File.directory?(filename)
+        block ? yield(filename) : true
       end
     end
   end

data/lib/chef/mixin/windows_architecture_helper.rb

@@ -74,11 +74,11 @@ class Chef
 
       def node_supports_windows_architecture?(node, desired_architecture)
         assert_valid_windows_architecture!(desired_architecture)
-        return ( node_windows_architecture(node) == :x86_64 ) || ( desired_architecture == :i386 )
+        ( node_windows_architecture(node) == :x86_64 ) || ( desired_architecture == :i386 )
       end
 
       def valid_windows_architecture?(architecture)
-        return ( architecture == :x86_64 ) || ( architecture == :i386 )
+        ( architecture == :x86_64 ) || ( architecture == :i386 )
       end
 
       def assert_valid_windows_architecture!(architecture)

data/lib/chef/mixin/xml_escape.rb

@@ -103,11 +103,9 @@ class Chef
           (0xE000..0xFFFD), (0x10000..0x10FFFF)]
 
         def xml_escape(unescaped_str)
-          begin
-            unescaped_str.unpack("U*").map { |char| xml_escape_char!(char) }.join
-          rescue
-            unescaped_str.unpack("C*").map { |char| xml_escape_char!(char) }.join
-          end
+          unescaped_str.unpack("U*").map { |char| xml_escape_char!(char) }.join
+        rescue
+          unescaped_str.unpack("C*").map { |char| xml_escape_char!(char) }.join
         end
 
         private

data/lib/chef/monkey_patches/webrick-utils.rb

@@ -44,7 +44,7 @@ module WEBrick
         end
       end
       raise last_error if sockets.empty?
-      return sockets
+      sockets
     end
     module_function :create_listeners
   end

data/lib/chef/node.rb

@@ -333,8 +333,8 @@ class Chef
 
       platform, version = Chef::Platform.find_platform_and_version(self)
       Chef::Log.debug("Platform is #{platform} version #{version}")
-      self.automatic[:platform] = platform
-      self.automatic[:platform_version] = version
+      automatic[:platform] = platform
+      automatic[:platform_version] = version
     end
 
     # Consumes the combined run_list and other attributes in +attrs+
@@ -343,7 +343,7 @@ class Chef
       normal_attrs_to_merge = consume_chef_environment(normal_attrs_to_merge)
       Chef::Log.debug("Applying attributes from json file")
       self.normal_attrs = Chef::Mixin::DeepMerge.merge(normal_attrs, normal_attrs_to_merge)
-      self.tags # make sure they're defined
+      tags # make sure they're defined
     end
 
     # Lazy initializer for tags attribute
@@ -394,8 +394,8 @@ class Chef
     # Clear defaults and overrides, so that any deleted attributes
     # between runs are still gone.
     def reset_defaults_and_overrides
-      self.default.clear
-      self.override.clear
+      default.clear
+      override.clear
     end
 
     # Expands the node's run list and sets the default and override
@@ -414,7 +414,7 @@ class Chef
       expansion = run_list.expand(chef_environment, data_source)
       raise Chef::Exceptions::MissingRole, expansion if expansion.errors?
 
-      self.tags # make sure they're defined
+      tags # make sure they're defined
 
       automatic_attrs[:recipes] = expansion.recipes.with_duplicate_names
       automatic_attrs[:expanded_run_list] = expansion.recipes.with_fully_qualified_names_and_version_constraints
@@ -632,14 +632,14 @@ class Chef
 
     def ==(other)
       if other.kind_of?(self.class)
-        self.name == other.name
+        name == other.name
       else
         false
       end
     end
 
     def <=>(other)
-      self.name <=> other.name
+      name <=> other.name
     end
 
     private

data/lib/chef/node/attribute.rb

@@ -454,19 +454,19 @@ class Chef
       end
 
       def write(level, *args, &block)
-        self.send(level).write(*args, &block)
+        send(level).write(*args, &block)
       end
 
       def write!(level, *args, &block)
-        self.send(level).write!(*args, &block)
+        send(level).write!(*args, &block)
       end
 
       def unlink(level, *path)
-        self.send(level).unlink(*path)
+        send(level).unlink(*path)
       end
 
       def unlink!(level, *path)
-        self.send(level).unlink!(*path)
+        send(level).unlink!(*path)
       end
 
       alias :attribute? :has_key?

data/lib/chef/node/common_api.rb

@@ -24,7 +24,7 @@ class Chef
       # method-style access to attributes
 
       def valid_container?(obj, key)
-        return obj.is_a?(Hash) || (obj.is_a?(Array) && key.is_a?(Integer))
+        obj.is_a?(Hash) || (obj.is_a?(Array) && key.is_a?(Integer))
       end
 
       private :valid_container?
@@ -85,16 +85,14 @@ class Chef
             end
           end
         end
-        return true
+        true
       end
 
       # this is a safe non-autovivifying reader that returns nil if the attribute does not exist
       def read(*path)
-        begin
-          read!(*path)
-        rescue Chef::Exceptions::NoSuchAttribute
-          nil
-        end
+        read!(*path)
+      rescue Chef::Exceptions::NoSuchAttribute
+        nil
       end
 
       # non-autovivifying reader that throws an exception if the attribute does not exist

data/lib/chef/org.rb

@@ -73,15 +73,15 @@ class Chef
     end
 
     def create
-      payload = { :name => self.name, :full_name => self.full_name }
+      payload = { :name => name, :full_name => full_name }
       new_org = chef_rest.post("organizations", payload)
-      Chef::Org.from_hash(self.to_hash.merge(new_org))
+      Chef::Org.from_hash(to_hash.merge(new_org))
     end
 
     def update
-      payload = { :name => self.name, :full_name => self.full_name }
+      payload = { :name => name, :full_name => full_name }
       new_org = chef_rest.put("organizations/#{name}", payload)
-      Chef::Org.from_hash(self.to_hash.merge(new_org))
+      Chef::Org.from_hash(to_hash.merge(new_org))
     end
 
     def destroy
@@ -89,14 +89,12 @@ class Chef
     end
 
     def save
-      begin
-        create
-      rescue Net::HTTPServerException => e
-        if e.response.code == "409"
-          update
-        else
-          raise e
-        end
+      create
+    rescue Net::HTTPServerException => e
+      if e.response.code == "409"
+        update
+      else
+        raise e
       end
     end
 

data/lib/chef/platform/provider_mapping.rb

@@ -35,7 +35,7 @@ class Chef
       include Chef::Mixin::ParamsValidate
 
       def find(name, version)
-        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find is deprecated")
+        Chef.deprecated(:chef_platform_methods, "#{self.name}.find is deprecated")
         provider_map = platforms[:default].clone
 
         name_sym = name
@@ -87,11 +87,11 @@ class Chef
 
         raise ArgumentError, "Cannot find a version for #{node}" unless version
 
-        return platform, version
+        [platform, version]
       end
 
       def provider_for_resource(resource, action = :nothing)
-        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.provider_for_resource is deprecated")
+        Chef.deprecated(:chef_platform_methods, "#{name}.provider_for_resource is deprecated")
         node = resource.run_context && resource.run_context.node
         raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
         provider = find_provider_for_node(node, resource).new(resource, resource.run_context)
@@ -100,17 +100,17 @@ class Chef
       end
 
       def provider_for_node(node, resource_type)
-        raise NotImplementedError, "#{self.class.name} no longer supports #provider_for_node"
+        raise NotImplementedError, "#{name} no longer supports #provider_for_node"
       end
 
       def find_provider_for_node(node, resource_type)
-        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find_provider_for_node is deprecated")
+        Chef.deprecated(:chef_platform_methods, "#{name}.find_provider_for_node is deprecated")
         platform, version = find_platform_and_version(node)
         find_provider(platform, version, resource_type)
       end
 
       def set(args)
-        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.set is deprecated")
+        Chef.deprecated(:chef_platform_methods, "#{name}.set is deprecated")
         validate(
           args,
           {
@@ -176,7 +176,7 @@ class Chef
       end
 
       def find_provider(platform, version, resource_type)
-        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find_provider is deprecated")
+        Chef.deprecated(:chef_platform_methods, "#{name}.find_provider is deprecated")
         provider_klass = explicit_provider(platform, version, resource_type) ||
           platform_provider(platform, version, resource_type) ||
           resource_matching_provider(platform, version, resource_type)