chef 13.7.16 → 13.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 480f6c57b309289e6a3165466b3ebe9b380d3303
-  data.tar.gz: 023ec9514fd41850c3e54937c79163f7f521f087
+  metadata.gz: 4cf91005817c8edd084d2eef52e54b9a320c79e8
+  data.tar.gz: d64f227f12314884d0f77a6a16fac2465251cd1c
 SHA512:
-  metadata.gz: 150f5e3c55254e1ebce602b76b40b2336a5c6693eb66ff2fa6eb2b521206495e3bb8adbe959da6929e352bf280f668a497d5c1c320ee608132dbe67f6a5e4a52
-  data.tar.gz: 86403121480ecf6bad98ad1b6738240997ad41e2baa3cfc2e43fcfddb07077fc0c06c5352b1e6a6aeebc9149c39170abc4d28e2b3e5ad0b588a598e14620151b
+  metadata.gz: 6593a7a47e0e16c9bae832c21f7fe19eab191fb005160f8094b88303a42bb8c0709e806c9d35a18ae15155782b1936454c58ec426089c995ceafe8fd95442da6
+  data.tar.gz: 802c38b93e6acf6e95961f854aa14ae65eed72f8d4b64b4dd80ba7835812b87ae3239ee657cb2f501ff40987ae872908cb2106c7451e98b06f8dca1aaeed7f74

data/VERSION

@@ -1 +1 @@
-13.7.16
+13.8.0

data/distro/common/man/man8/chef-solo.8

@@ -79,7 +79,7 @@ The configuration file to use.
 .B \fB\-d\fP, \fB\-\-daemonize\fP
 Use to run the executable as a daemon.  This option may not be used in the same command with the \fB\-\-[no\-]fork\fP option.
 .sp
-This option is only available on machines that run in UNIX or Linux environments. For machines that are running Microsoft Windows that require similar functionality, use the \fBchef\-client::service\fP recipe in the \fBchef\-client\fP cookbook: \fI\%http://community.opscode.com/cookbooks/chef\-client\fP\&. This will install a chef\-client service under Microsoft Windows using the Windows Service Wrapper\&.
+This option is only available on machines that run in UNIX or Linux environments. For machines that are running Microsoft Windows that require similar functionality, use the \fBchef\-client::service\fP recipe in the \fBchef\-client\fP cookbook: \fI\%http://community.opscode.com/cookbooks/chef\-client\fP\&.  This will install a chef\-client service under Microsoft Windows using the Windows Service Wrapper\&.
 .TP
 .B \fB\-E ENVIRONMENT_NAME\fP, \fB\-\-environment ENVIRONMENT_NAME\fP
 The name of the environment.

data/lib/chef/chef_fs/data_handler/organization_invites_data_handler.rb

@@ -5,7 +5,7 @@ class Chef
     module DataHandler
       class OrganizationInvitesDataHandler < DataHandlerBase
         def normalize(invites, entry)
-          invites.map { |invite| invite.is_a?(Hash) ? invite["username"] : invite }.sort.uniq
+          invites.map { |invite| invite.is_a?(Hash) ? invite["username"] : invite }.compact.sort.uniq
         end
 
         def minimize(invites, entry)

data/lib/chef/knife/bootstrap.rb

@@ -448,7 +448,7 @@ class Chef
         ssh.config[:ssh_identity_file] = config[:ssh_identity_file] || config[:identity_file]
         ssh.config[:manual] = true
         ssh.config[:host_key_verify] = config[:host_key_verify]
-        ssh.config[:on_error] = :raise
+        ssh.config[:on_error] = true
         ssh
       end
 

data/lib/chef/knife/search.rb

@@ -98,7 +98,9 @@ class Chef
         begin
           q.search(@type, @query, search_args) do |item|
             formatted_item = Hash.new
-            if item.is_a?(Hash)
+            if config[:id_only]
+              formatted_item = format_for_display({ "id" => item["__display_name"] })
+            elsif item.is_a?(Hash)
               # doing a little magic here to set the correct name
               formatted_item[item["__display_name"]] = item.reject { |k| k == "__display_name" }
             else

data/lib/chef/knife/ssh.rb

@@ -125,7 +125,7 @@ class Chef
         :long => "--exit-on-error",
         :description => "Immediately exit if an error is encountered",
         :boolean => true,
-        :proc => Proc.new { :raise }
+        :default => false
 
       option :tmux_split,
         :long => "--tmux-split",
@@ -134,15 +134,13 @@ class Chef
         :default => false
 
       def session
-        config[:on_error] ||= :skip
         ssh_error_handler = Proc.new do |server|
-          case config[:on_error]
-          when :skip
-            ui.warn "Failed to connect to #{server.host} -- #{$!.class.name}: #{$!.message}"
-            $!.backtrace.each { |l| Chef::Log.debug(l) }
-          when :raise
+          if config[:on_error]
             #Net::SSH::Multi magic to force exception to be re-raised.
             throw :go, :raise
+          else
+            ui.warn "Failed to connect to #{server.host} -- #{$!.class.name}: #{$!.message}"
+            $!.backtrace.each { |l| Chef::Log.debug(l) }
           end
         end
 

data/lib/chef/node/attribute.rb

@@ -17,6 +17,7 @@
 # limitations under the License.
 #
 
+require "chef/node/mixin/deep_merge_cache"
 require "chef/node/mixin/immutablize_hash"
 require "chef/node/mixin/state_tracking"
 require "chef/node/immutable_collections"
@@ -44,6 +45,7 @@ class Chef
       # expects.  This include should probably be deleted?
       include Enumerable
 
+      include Chef::Node::Mixin::DeepMergeCache
       include Chef::Node::Mixin::StateTracking
       include Chef::Node::Mixin::ImmutablizeHash
 
@@ -185,9 +187,6 @@ class Chef
        # return the automatic level attribute component
       attr_reader :automatic
 
-      # return the immutablemash deep merge cache
-      attr_reader :deep_merge_cache
-
       def initialize(normal, default, override, automatic, node = nil)
         @default        = VividMash.new(default, self, node, :default)
         @env_default    = VividMash.new({}, self, node, :env_default)
@@ -203,8 +202,7 @@ class Chef
 
         @automatic      = VividMash.new(automatic, self, node, :automatic)
 
-        @deep_merge_cache = ImmutableMash.new({}, self, node, :merged)
-        @__node__ = node
+        super(nil, self, node, :merged)
       end
 
        # Debug what's going on with an attribute. +args+ is a path spec to the
@@ -228,22 +226,6 @@ class Chef
         end
       end
 
-      def reset
-        @deep_merge_cache = ImmutableMash.new({}, self, @__node__, :merged)
-      end
-
-      def reset_cache(*path)
-        if path.empty?
-          reset
-        else
-          container = read(*path)
-          case container
-          when Hash, Array
-            container.reset
-          end
-        end
-      end
-
        # Set the cookbook level default attribute component to +new_data+.
       def default=(new_data)
         reset
@@ -308,7 +290,7 @@ class Chef
 
        # clears attributes from all precedence levels
       def rm(*args)
-        with_deep_merged_return_value(combined_all, *args) do
+        with_deep_merged_return_value(self, *args) do
           rm_default(*args)
           rm_normal(*args)
           rm_override(*args)
@@ -355,9 +337,6 @@ class Chef
       def with_deep_merged_return_value(obj, *path, last)
         hash = obj.read(*path)
         return nil unless hash.is_a?(Hash)
-        # coerce from immutablemash/vividmash to plain-old Hash
-        # also de-immutablizes and dup's the return value correctly in chef-13
-        hash = hash.to_hash
         ret = hash[last]
         yield
         ret
@@ -419,16 +398,16 @@ class Chef
        # all of node['foo'] even if the user only requires node['foo']['bar']['baz'].
        #
 
-      def combined_override(*path)
-        merge_overrides(path)
+      def merged_attributes(*path)
+        merge_all(path)
       end
 
-      def combined_all(*path)
-        path.empty? ? self : read(*path)
+      def combined_override(*path)
+        immutablize(merge_overrides(path))
       end
 
       def combined_default(*path)
-        merge_defaults(path)
+        immutablize(merge_defaults(path))
       end
 
       def normal_unless(*args)
@@ -497,14 +476,6 @@ class Chef
         merged_attributes.to_s
       end
 
-      def [](key)
-        @deep_merge_cache[key]
-      end
-
-      def merged_attributes
-        @deep_merge_cache
-      end
-
       def inspect
         "#<#{self.class} " << (COMPONENTS + [:@merged_attributes, :@properties]).map do |iv|
           "#{iv}=#{instance_variable_get(iv).inspect}"
@@ -513,14 +484,7 @@ class Chef
 
       private
 
-      # For elements like Fixnums, true, nil...
-      def safe_dup(e)
-        e.dup
-      rescue TypeError
-        e
-      end
-
-       # Helper method for merge_defaults/merge_overrides.
+       # Helper method for merge_all/merge_defaults/merge_overrides.
        #
        # apply_path(thing, [ "foo", "bar", "baz" ]) = thing["foo"]["bar"]["baz"]
        #
@@ -550,6 +514,34 @@ class Chef
         end
       end
 
+       # For elements like Fixnums, true, nil...
+      def safe_dup(e)
+        e.dup
+      rescue TypeError
+        e
+      end
+
+       # Deep merge all attribute levels using hash-only merging between different precidence
+       # levels (so override arrays completely replace arrays set at any default level).
+       #
+       # The path allows for selectively deep-merging a subtree of the node object.
+       #
+       # @param path [Array] Array of args to method chain to descend into the node object
+       # @return [attr] Deep Merged values (may be VividMash, Hash, Array, etc) from the node object
+      def merge_all(path)
+        components = [
+          merge_defaults(path),
+          apply_path(@normal, path),
+          merge_overrides(path),
+          apply_path(@automatic, path),
+        ]
+
+        ret = components.inject(NIL) do |merged, component|
+          hash_only_merge!(merged, component)
+        end
+        ret == NIL ? nil : ret
+      end
+
        # Deep merge the default attribute levels with array merging.
        #
        # The path allows for selectively deep-merging a subtree of the node object.
@@ -621,6 +613,38 @@ class Chef
         end
       end
 
+      # @api private
+      def hash_only_merge!(merge_onto, merge_with)
+        # If there are two Hashes, recursively merge.
+        if merge_onto.kind_of?(Hash) && merge_with.kind_of?(Hash)
+          merge_with.each do |key, merge_with_value|
+            value =
+              if merge_onto.has_key?(key)
+                hash_only_merge!(safe_dup(merge_onto[key]), merge_with_value)
+              else
+                merge_with_value
+              end
+
+            # internal_set bypasses converting keys, does convert values and allows writing to immutable mashes
+            merge_onto.internal_set(key, value)
+          end
+          merge_onto
+
+        # If merge_with is nil, don't replace merge_onto
+        elsif merge_with.nil?
+          merge_onto
+
+        # In all other cases, replace merge_onto with merge_with
+        else
+          if merge_with.kind_of?(Hash)
+            Chef::Node::ImmutableMash.new(merge_with)
+          elsif merge_with.kind_of?(Array)
+            Chef::Node::ImmutableArray.new(merge_with)
+          else
+            merge_with
+          end
+        end
+      end
     end
   end
 end

data/lib/chef/node/attribute_collections.rb

@@ -63,13 +63,13 @@ class Chef
       MUTATOR_METHODS.each do |mutator|
         define_method(mutator) do |*args, &block|
           ret = super(*args, &block)
-          send_reset_cache(__path__)
+          send_reset_cache
           ret
         end
       end
 
       def delete(key, &block)
-        send_reset_cache(__path__)
+        send_reset_cache(__path__, key)
         super
       end
 
@@ -147,13 +147,13 @@ class Chef
       # object.
 
       def delete(key, &block)
-        send_reset_cache(__path__)
+        send_reset_cache(__path__, key)
         super
       end
 
       MUTATOR_METHODS.each do |mutator|
         define_method(mutator) do |*args, &block|
-          send_reset_cache(__path__)
+          send_reset_cache
           super(*args, &block)
         end
       end
@@ -174,7 +174,7 @@ class Chef
 
       def []=(key, value)
         ret = super
-        send_reset_cache(__path__)
+        send_reset_cache(__path__, key)
         ret
       end
 

data/lib/chef/node/common_api.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright:: Copyright 2016-2017, Chef Software Inc.
+# Copyright:: Copyright 2016, Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/lib/chef/node/immutable_collections.rb

@@ -30,16 +30,22 @@ class Chef
         e
       end
 
-      def convert_value(value, path = nil)
+      def convert_value(value)
         case value
         when Hash
-          ImmutableMash.new({}, __root__, __node__, __precedence__, path)
+          ImmutableMash.new(value, __root__, __node__, __precedence__)
         when Array
-          ImmutableArray.new([], __root__, __node__, __precedence__, path)
+          ImmutableArray.new(value, __root__, __node__, __precedence__)
+        when ImmutableMash, ImmutableArray
+          value
         else
           safe_dup(value).freeze
         end
       end
+
+      def immutablize(value)
+        convert_value(value)
+      end
     end
 
     # == ImmutableArray
@@ -53,49 +59,15 @@ class Chef
     #   Chef::Node::Attribute's values, it overrides all reader methods to
     #   detect staleness and raise an error if accessed when stale.
     class ImmutableArray < Array
-      alias_method :internal_clear, :clear
-      alias_method :internal_replace, :replace
-      alias_method :internal_push, :<<
-      alias_method :internal_to_a, :to_a
-      alias_method :internal_each, :each
-      private :internal_push, :internal_replace, :internal_clear, :internal_each
-      protected :internal_to_a
-
       include Immutablize
 
-      methods = Array.instance_methods - Object.instance_methods +
-        [ :!, :!=, :<=>, :==, :===, :eql?, :to_s, :hash, :key, :has_key?, :inspect, :pretty_print, :pretty_print_inspect, :pretty_print_cycle, :pretty_print_instance_variables ]
-
-      methods.each do |method|
-        define_method method do |*args, &block|
-          ensure_generated_cache!
-          super(*args, &block)
-        end
-      end
-
-      def each
-        ensure_generated_cache!
-        # aggressively pre generate the cache, works around ruby being too smart and fiddling with internals
-        internal_each { |i| i.ensure_generated_cache! if i.respond_to?(:ensure_generated_cache!) }
-        super
-      end
-
-      # because sometimes ruby gives us back Arrays or ImmutableArrays out of objects from things like #uniq or array slices
-      def return_normal_array(array)
-        if array.respond_to?(:internal_to_a, true)
-          array.internal_to_a
-        else
-          array.to_a
-        end
-      end
-
-      def uniq
-        ensure_generated_cache!
-        return_normal_array(super)
-      end
+      alias :internal_push :<<
+      private :internal_push
 
       def initialize(array_data = [])
-        # Immutable collections no longer have initialized state
+        array_data.each do |value|
+          internal_push(immutablize(value))
+        end
       end
 
       # For elements like Fixnums, true, nil...
@@ -124,81 +96,8 @@ class Chef
 
       alias_method :to_array, :to_a
 
-      def [](*args)
-        ensure_generated_cache!
-        args.length > 1 ? return_normal_array(super) : super # correctly handle array slices
-      end
-
-      def reset
-        @generated_cache = false
-        @short_circuit_attr_level = nil
-        internal_clear # redundant?
-      end
-
-      # @api private
-      def ensure_generated_cache!
-        generate_cache unless @generated_cache
-        @generated_cache = true
-      end
-
-      # This can be set to e.g. [ :@default ] by the parent container to cause this container
-      # to only use the default level and to bypass deep merging (the common case is either
-      # default-level or automatic-level and we aren't doing any deep merging).  Right now it
-      # "optimized" for the case where we're no longer merging anything and only tracking a
-      # single level, and setting this to anything other than a size=1 array would behave
-      # in a broken fashion.  That could be fixed, but the perf boost would likely not be
-      # that large in the typical case.
-      #
-      # @api private
-      attr_accessor :short_circuit_attr_levels
-
       private
 
-      # deep merging of array attribute within normal and override where they are merged together
-      def combined_components(components)
-        combined_values = nil
-        components.each do |component|
-          values = __node__.attributes.instance_variable_get(component).read(*__path__)
-          next unless values.is_a?(Array)
-          @tracked_components << component
-          combined_values ||= []
-          combined_values += values
-        end
-        combined_values
-      end
-
-      def get_array(component)
-        array = __node__.attributes.instance_variable_get(component).read(*__path__)
-        if array.is_a?(Array)
-          @tracked_components << component
-          array
-        end # else nil
-      end
-
-      def generate_cache
-        internal_clear
-        components = []
-        @tracked_components = []
-        if short_circuit_attr_levels
-          components << get_array(short_circuit_attr_levels.first)
-        else
-          components << combined_components(Attribute::DEFAULT_COMPONENTS)
-          components << get_array(:@normal)
-          components << combined_components(Attribute::OVERRIDE_COMPONENTS)
-          components << get_array(:@automatic)
-        end
-        highest = components.compact.last
-        if highest.is_a?(Array)
-          internal_replace( highest.each_with_index.map { |x, i| convert_value(x, __path__ + [ i ] ) } )
-        end
-        if @tracked_components.size == 1
-          # tracked_components is accurate enough to tell us if we're not really merging
-          internal_each do |key, value|
-            value.short_circuit_attr_levels = @tracked_components if value.respond_to?(:short_circuit_attr_levels)
-          end
-        end
-      end
-
       # needed for __path__
       def convert_key(key)
         key
@@ -221,31 +120,19 @@ class Chef
     #   it is stale.
     # * Values can be accessed in attr_reader-like fashion via method_missing.
     class ImmutableMash < Mash
-      alias_method :internal_clear, :clear
-      alias_method :internal_key?, :key? # FIXME: could bypass convert_key in Mash for perf
-      alias_method :internal_each, :each
-
       include Immutablize
       include CommonAPI
 
-      methods = Hash.instance_methods - Object.instance_methods +
-        [ :!, :!=, :<=>, :==, :===, :eql?, :to_s, :hash, :key, :has_key?, :inspect, :pretty_print, :pretty_print_inspect, :pretty_print_cycle, :pretty_print_instance_variables ]
-
-      methods.each do |method|
-        define_method method do |*args, &block|
-          ensure_generated_cache!
-          super(*args, &block)
-        end
-      end
-
       # this is for deep_merge usage, chef users must never touch this API
       # @api private
       def internal_set(key, value)
-        regular_writer(key, convert_value(value, __path__ + [ key ]))
+        regular_writer(key, convert_value(value))
       end
 
       def initialize(mash_data = {})
-        # Immutable collections no longer have initialized state
+        mash_data.each do |key, value|
+          internal_set(key, value)
+        end
       end
 
       alias :attribute? :has_key?
@@ -281,55 +168,11 @@ class Chef
 
       alias_method :to_hash, :to_h
 
-      def [](key)
-        ensure_generated_cache!
-        super
-      end
-
-      alias_method :to_hash, :to_h
-
-      def reset
-        @generated_cache = false
-        @short_circuit_attr_level = nil
-        internal_clear # redundant?
-      end
-
-      # @api private
-      def ensure_generated_cache!
-        generate_cache unless @generated_cache
-        @generated_cache = true
-      end
-
-      # @api private
-      attr_accessor :short_circuit_attr_levels
-
-      private
-
-      def generate_cache
-        internal_clear
-        components = short_circuit_attr_levels ? short_circuit_attr_levels : Attribute::COMPONENTS.reverse
-        # tracked_components is not entirely accurate due to the short-circuit
-        tracked_components = []
-        components.each do |component|
-          subhash = __node__.attributes.instance_variable_get(component).read(*__path__)
-          unless subhash.nil? # FIXME: nil is used for not present
-            tracked_components << component
-            if subhash.kind_of?(Hash)
-              subhash.keys.each do |key|
-                next if internal_key?(key)
-                internal_set(key, subhash[key])
-              end
-            else
-              break
-            end
-          end
-        end
-        if tracked_components.size == 1
-          # tracked_components is accurate enough to tell us if we're not really merging
-          internal_each do |key, value|
-            value.short_circuit_attr_levels = tracked_components if value.respond_to?(:short_circuit_attr_levels)
-          end
-        end
+      # For elements like Fixnums, true, nil...
+      def safe_dup(e)
+        e.dup
+      rescue TypeError
+        e
       end
 
       prepend Chef::Node::Mixin::StateTracking