chef 12.5.1-universal-mingw32 → 12.6.0-universal-mingw32

data/lib/chef/mixin/proxified_socket.rb

@@ -0,0 +1,38 @@
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright (c) 2015 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.
+#
+
+require 'proxifier'
+
+class Chef
+  module Mixin
+    module ProxifiedSocket
+
+      # This looks at the environment variables and leverages Proxifier to
+      # make the TCPSocket respect ENV['https_proxy'] or ENV['http_proxy'] if
+      # they are present
+      def proxified_socket(host, port)
+        proxy = ENV['https_proxy'] || ENV['http_proxy'] || false
+        if proxy
+          Proxifier.Proxy(proxy, no_proxy: ENV['no_proxy']).open(host, port)
+        else
+          TCPSocket.new(host, port)
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/mixin/subclass_directive.rb

@@ -0,0 +1,37 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008-2015 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 SubclassDirective
+      def subclass_directive(sym)
+        define_singleton_method sym do
+          instance_variable_set(:"@#{sym}", true)
+        end
+
+        define_singleton_method :"#{sym}?" do
+          !!instance_variable_get(:"@#{sym}")
+        end
+
+        define_method :"#{sym}?" do
+          self.class.send(:"#{sym}?")
+        end
+      end
+    end
+  end
+end

data/lib/chef/node.rb

@@ -376,12 +376,12 @@ class Chef
       normal[:tags]
     end
 
-    def tag(*tags)
-      tags.each do |tag|
-        self.normal[:tags].push(tag.to_s) unless self[:tags].include? tag.to_s
+    def tag(*args)
+      args.each do |tag|
+        tags.push(tag.to_s) unless tags.include? tag.to_s
       end
 
-      self[:tags]
+      tags
     end
 
     # Extracts the run list from +attrs+ and applies it. Returns the remaining attributes
@@ -609,7 +609,7 @@ class Chef
       # so then POST to create.
       begin
         if Chef::Config[:why_run]
-          Chef::Log.warn("In whyrun mode, so NOT performing node save.")
+          Chef::Log.warn("In why-run mode, so NOT performing node save.")
         else
           chef_server_rest.put_rest("nodes/#{name}", data_for_save)
         end
@@ -647,6 +647,14 @@ class Chef
       "node[#{name}]"
     end
 
+    def ==(other)
+      if other.kind_of?(self.class)
+         self.name == other.name
+      else
+        false
+      end
+    end
+
     def <=>(other_node)
       self.name <=> other_node.name
     end

data/lib/chef/platform/query_helpers.rb

@@ -85,10 +85,12 @@ class Chef
       end
 
       def supports_dsc_invoke_resource?(node)
-        require 'rubygems'
         supports_dsc?(node) &&
-          Gem::Version.new(node[:languages][:powershell][:version]) >=
-            Gem::Version.new("5.0.10018.0")
+          supported_powershell_version?(node, "5.0.10018.0")
+      end
+
+      def supports_refresh_mode_enabled?(node)
+        supported_powershell_version?(node, "5.0.10586.0")
       end
 
       def dsc_refresh_mode_disabled?(node)
@@ -97,6 +99,15 @@ class Chef
         metadata = cmdlet.run!.return_value
         metadata['RefreshMode'] == 'Disabled'
       end
+      
+
+      def supported_powershell_version?(node, version_string)
+        return false unless node[:languages] && node[:languages][:powershell]
+        require 'rubygems'
+        Gem::Version.new(node[:languages][:powershell][:version]) >=
+          Gem::Version.new(version_string)
+      end
+
     end
   end
 end

data/lib/chef/platform/service_helpers.rb

@@ -16,19 +16,12 @@
 # limitations under the License.
 #
 
-# XXX: mixing shellout into a mixin into classes has to be code smell
-require 'chef/mixin/shell_out'
-require 'chef/mixin/which'
 require 'chef/chef_class'
 
 class Chef
   class Platform
     class ServiceHelpers
       class << self
-
-        include Chef::Mixin::ShellOut
-        include Chef::Mixin::Which
-
         # This helper is mostly used to sort out the mess of different
         # linux mechanisms that can be used to start services.  It does
         # not necessarily need to linux-specific, but currently all our
@@ -53,23 +46,22 @@ class Chef
             providers << :invokercd
           end
 
+          if ::File.exist?(Chef.path_to("/sbin/initctl"))
+            providers << :upstart
+          end
+
           if ::File.exist?(Chef.path_to("/sbin/insserv"))
             providers << :insserv
           end
 
-          # debian >= 6.0 has /etc/init but does not have upstart
-          if ::File.exist?(Chef.path_to("/etc/init")) && ::File.exist?(Chef.path_to("/sbin/start"))
-            providers << :upstart
+          if systemd_is_init?
+            providers << :systemd
           end
 
           if ::File.exist?(Chef.path_to("/sbin/chkconfig"))
             providers << :redhat
           end
 
-          if systemd_sanity_check?
-            providers << :systemd
-          end
-
           providers
         end
 
@@ -96,7 +88,7 @@ class Chef
             configs << :usr_local_etc_rcd
           end
 
-          if systemd_sanity_check? && platform_has_systemd_unit?(service_name)
+          if has_systemd_service_unit?(service_name) || has_systemd_unit?(service_name)
             configs << :systemd
           end
 
@@ -105,34 +97,24 @@ class Chef
 
         private
 
-        def systemctl_path
-          which("systemctl")
+        def systemd_is_init?
+          ::File.exist?(Chef.path_to("/proc/1/comm")) &&
+            ::File.open(Chef.path_to("/proc/1/comm")).gets.chomp == "systemd" 
         end
 
-        def systemd_sanity_check?
-          systemctl_path && File.exist?(Chef.path_to("/proc/1/comm")) && File.open(Chef.path_to("/proc/1/comm")).gets.chomp == "systemd"
-        end
-
-        def extract_systemd_services(command)
-          output = shell_out!(command).stdout
-          # first line finds e.g. "sshd.service"
-          services = []
-          output.each_line do |line|
-            fields = line.split
-            services << fields[0] if fields[1] == "loaded" || fields[1] == "not-found"
+        def has_systemd_service_unit?(svc_name)
+          %w( /etc /usr/lib /lib /run ).any? do |load_path|
+            ::File.exist?(
+              Chef.path_to("#{load_path}/systemd/system/#{svc_name.gsub(/@.*$/, '@')}.service")
+            )
           end
-          # this splits off the suffix after the last dot to return "sshd"
-          services += services.select {|s| s.match(/\.service$/) }.map { |s| s.sub(/(.*)\.service$/, '\1') }
-        rescue Mixlib::ShellOut::ShellCommandFailed
-          []
         end
 
-        def platform_has_systemd_unit?(service_name)
-          services = extract_systemd_services("#{systemctl_path} --all") +
-            extract_systemd_services("#{systemctl_path} list-unit-files")
-          services.include?(service_name)
-        rescue Mixlib::ShellOut::ShellCommandFailed
-          false
+        def has_systemd_unit?(svc_name)
+          # TODO: stop supporting non-service units with service resource
+          %w( /etc /usr/lib /lib /run ).any? do |load_path|
+            ::File.exist?(Chef.path_to("#{load_path}/systemd/system/#{svc_name}"))
+          end
         end
       end
     end

data/lib/chef/policy_builder/expand_node_object.rb

@@ -74,11 +74,13 @@ class Chef
           cl = Chef::CookbookLoader.new(Chef::Config[:cookbook_path])
           cl.load_cookbooks
           cookbook_collection = Chef::CookbookCollection.new(cl)
+          cookbook_collection.validate!
           run_context = Chef::RunContext.new(node, cookbook_collection, @events)
         else
           Chef::Cookbook::FileVendor.fetch_from_remote(api_service)
           cookbook_hash = sync_cookbooks
           cookbook_collection = Chef::CookbookCollection.new(cookbook_hash)
+          cookbook_collection.validate!
           run_context = Chef::RunContext.new(node, cookbook_collection, @events)
         end
 
@@ -154,6 +156,7 @@ class Chef
         Chef::Log.info("Run List expands to [#{@expanded_run_list_with_versions.join(', ')}]")
 
         events.node_load_completed(node, @expanded_run_list_with_versions, Chef::Config)
+        events.run_list_expanded(@run_list_expansion)
 
         node
       end

data/lib/chef/policy_builder/policyfile.rb

@@ -153,6 +153,7 @@ class Chef
         Chef::Cookbook::FileVendor.fetch_from_remote(http_api)
         sync_cookbooks
         cookbook_collection = Chef::CookbookCollection.new(cookbooks_to_sync)
+        cookbook_collection.validate!
         run_context = Chef::RunContext.new(node, cookbook_collection, events)
 
         setup_chef_class(run_context)

data/lib/chef/property.rb

@@ -18,6 +18,8 @@
 
 require 'chef/exceptions'
 require 'chef/delayed_evaluator'
+require 'chef/chef_class'
+require 'chef/log'
 
 class Chef
   #
@@ -116,6 +118,10 @@ class Chef
       options[:instance_variable_name] = options[:instance_variable_name].to_sym if options[:instance_variable_name]
     end
 
+    def to_s
+      name
+    end
+
     #
     # The name of this property.
     #
@@ -247,16 +253,19 @@ class Chef
         return get(resource)
       end
 
-      # myprop nil is sometimes a get (backcompat)
       if value.nil? && !explicitly_accepts_nil?(resource)
-        # If you say "my_property nil" and the property explicitly accepts
-        # nil values, we consider this a get.
-        Chef.log_deprecation("#{name} nil currently does not overwrite the value of #{name}. This will change in Chef 13, and the value will be set to nil instead. Please change your code to explicitly accept nil using \"property :#{name}, [MyType, nil]\", or stop setting this value to nil.")
-        return get(resource)
+        # In Chef 12, value(nil) does a *get* instead of a set, so we
+        # warn if the value would have been changed. In Chef 13, it will be
+        # equivalent to value = nil.
+        result = get(resource)
+        if !result.nil?
+          Chef.log_deprecation("#{name} nil currently does not overwrite the value of #{name}. This will change in Chef 13, and the value will be set to nil instead. Please change your code to explicitly accept nil using \"property :#{name}, [MyType, nil]\", or stop setting this value to nil.")
+        end
+        result
+      else
+        # Anything else, such as myprop(value) is a set
+        set(resource, value)
       end
-
-      # Anything else (myprop value) is a set
-      set(resource, value)
     end
 
     #
@@ -292,6 +301,29 @@ class Chef
         value
 
       else
+        # If the user does something like this:
+        #
+        # ```
+        # class MyResource < Chef::Resource
+        #   property :content
+        #   action :create do
+        #     file '/x.txt' do
+        #       content content
+        #     end
+        #   end
+        # end
+        # ```
+        #
+        # It won't do what they expect. This checks whether you try to *read*
+        # `content` while we are compiling the resource.
+        if resource.respond_to?(:resource_initializing) &&
+           resource.resource_initializing &&
+           resource.respond_to?(:enclosing_provider) &&
+           resource.enclosing_provider &&
+           resource.enclosing_provider.respond_to?(name)
+           Chef::Log.warn("#{Chef::Log.caller_location}: property #{name} is declared in both #{resource} and #{resource.enclosing_provider}. Use new_resource.#{name} instead. At #{Chef::Log.caller_location}")
+        end
+
         if has_default?
           value = default
           if value.is_a?(DelayedEvaluator)
@@ -431,7 +463,7 @@ class Chef
          modified_options.has_key?(:default)
         options = options.reject { |k,v| k == :name_attribute || k == :name_property || k == :default }
       end
-      Property.new(options.merge(modified_options))
+      self.class.new(options.merge(modified_options))
     end
 
     #
@@ -448,18 +480,22 @@ class Chef
       # stack trace if you use `define_method`.
       declared_in.class_eval <<-EOM, __FILE__, __LINE__+1
         def #{name}(value=NOT_PASSED)
+          raise "Property #{name} of \#{self} cannot be passed a block! If you meant to create a resource named #{name} instead, you'll need to first rename the property." if block_given?
           self.class.properties[#{name.inspect}].call(self, value)
         end
         def #{name}=(value)
+          raise "Property #{name} of \#{self} cannot be passed a block! If you meant to create a resource named #{name} instead, you'll need to first rename the property." if block_given?
           self.class.properties[#{name.inspect}].set(self, value)
         end
       EOM
     rescue SyntaxError
       # If the name is not a valid ruby name, we use define_method.
-      declared_in.define_method(name) do |value=NOT_PASSED|
+      declared_in.define_method(name) do |value=NOT_PASSED, &block|
+        raise "Property #{name} of #{self} cannot be passed a block! If you meant to create a resource named #{name} instead, you'll need to first rename the property." if block
         self.class.properties[name].call(self, value)
       end
-      declared_in.define_method("#{name}=") do |value|
+      declared_in.define_method("#{name}=") do |value, &block|
+        raise "Property #{name} of #{self} cannot be passed a block! If you meant to create a resource named #{name} instead, you'll need to first rename the property." if block
         self.class.properties[name].set(self, value)
       end
     end
@@ -479,6 +515,8 @@ class Chef
     # A type accepts nil explicitly if "is" allows nil, it validates as nil, *and* is not simply
     # an empty type.
     #
+    # A type is presumed to accept nil if it does coercion (which must handle nil).
+    #
     # These examples accept nil explicitly:
     # ```ruby
     # property :a, [ String, nil ]
@@ -510,7 +548,8 @@ class Chef
     #
     # @api private
     def explicitly_accepts_nil?(resource)
-      options.has_key?(:is) && resource.send(:_pv_is, { name => nil }, name, options[:is], raise_error: false)
+      options.has_key?(:coerce) ||
+      (options.has_key?(:is) && resource.send(:_pv_is, { name => nil }, name, options[:is], raise_error: false))
     end
 
     def get_value(resource)

data/lib/chef/provider.rb

@@ -204,26 +204,39 @@ class Chef
         specified_properties = properties.select { |property| new_resource.property_is_set?(property) }
         modified = specified_properties.select { |p| new_resource.send(p) != current_resource.send(p) }
         if modified.empty?
-          Chef::Log.debug("Skipping update of #{new_resource.to_s}: has not changed any of the specified properties #{specified_properties.map { |p| "#{p}=#{new_resource.send(p).inspect}" }.join(", ")}.")
+          properties_str = if sensitive
+            specified_properties.join(", ")
+          else
+            specified_properties.map { |p| "#{p}=#{new_resource.send(p).inspect}" }.join(", ")
+          end
+          Chef::Log.debug("Skipping update of #{new_resource.to_s}: has not changed any of the specified properties #{properties_str}.")
           return false
         end
 
         # Print the pretty green text and run the block
         property_size = modified.map { |p| p.size }.max
-        modified = modified.map { |p| "  set #{p.to_s.ljust(property_size)} to #{new_resource.send(p).inspect} (was #{current_resource.send(p).inspect})" }
+        modified.map! do |p|
+          properties_str = if sensitive
+            '(suppressed sensitive property)'
+          else
+            "#{new_resource.send(p).inspect} (was #{current_resource.send(p).inspect})"
+          end
+          "  set #{p.to_s.ljust(property_size)} to #{properties_str}"
+        end
         converge_by([ "update #{current_resource.identity}" ] + modified, &converge_block)
 
       else
         # The resource doesn't exist. Mark that we are *creating* this, and
         # write down any properties we are setting.
         property_size = properties.map { |p| p.size }.max
-        created = []
-        properties.each do |property|
-          if new_resource.property_is_set?(property)
-            created << "  set #{property.to_s.ljust(property_size)} to #{new_resource.send(property).inspect}"
+        created = properties.map do |property|
+          default = ' (default value)' unless new_resource.property_is_set?(property)
+          properties_str = if sensitive
+            '(suppressed sensitive property)'
           else
-            created << "  set #{property.to_s.ljust(property_size)} to #{new_resource.send(property).inspect} (default value)"
+            new_resource.send(property).inspect
           end
+          "  set #{property.to_s.ljust(property_size)} to #{properties_str}#{default}"
         end
 
         converge_by([ "create #{new_resource.identity}" ] + created, &converge_block)
@@ -338,10 +351,20 @@ class Chef
     # @api private
     module InlineResources
 
-      # Our run context is a child of the main run context; that gives us a
-      # whole new resource collection and notification set.
-      def initialize(resource, run_context)
-        super(resource, run_context.create_child)
+      # Create a child run_context, compile the block, and converge it.
+      #
+      # @api private
+      def compile_and_converge_action(&block)
+        old_run_context = run_context
+        @run_context = run_context.create_child
+        return_value = instance_eval(&block)
+        Chef::Runner.new(run_context).converge
+        return_value
+      ensure
+        if run_context.resource_collection.any? { |r| r.updated? }
+          new_resource.updated_by_last_action(true)
+        end
+        @run_context = old_run_context
       end
 
       # Class methods for InlineResources. Overrides the `action` DSL method
@@ -353,36 +376,18 @@ class Chef
         # compile the resources, converging them, and then checking if any
         # were updated (and updating new-resource if so)
         def action(name, &block)
-          # We first try to create the method using "def method_name", which is
-          # preferred because it actually shows up in stack traces. If that
-          # fails, we try define_method.
+          # We need the block directly in a method so that `super` works
+          define_method("compile_action_#{name}", &block)
+          # We try hard to use `def` because define_method doesn't show the method name in the stack.
           begin
-            class_eval <<-EOM, __FILE__, __LINE__+1
+            class_eval <<-EOM
               def action_#{name}
-                return_value = compile_action_#{name}
-                Chef::Runner.new(run_context).converge
-                return_value
-              ensure
-                if run_context.resource_collection.any? {|r| r.updated? }
-                  new_resource.updated_by_last_action(true)
-                end
+                compile_and_converge_action { compile_action_#{name} }
               end
             EOM
           rescue SyntaxError
-            define_method("action_#{name}") do
-              begin
-                return_value = send("compile_action_#{name}")
-                Chef::Runner.new(run_context).converge
-                return_value
-              ensure
-                if run_context.resource_collection.any? {|r| r.updated? }
-                  new_resource.updated_by_last_action(true)
-                end
-              end
-            end
+            define_method("action_#{name}") { send("compile_action_#{name}") }
           end
-          # We put the action in its own method so that super() works.
-          define_method("compile_action_#{name}", &block)
         end
       end