chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/lib/chef/provider.rb

@@ -26,6 +26,7 @@ require 'chef/mixin/powershell_out'
 require 'chef/mixin/provides'
 require 'chef/platform/service_helpers'
 require 'chef/node_map'
+require 'forwardable'
 
 class Chef
   class Provider
@@ -65,6 +66,7 @@ class Chef
 
       @recipe_name = nil
       @cookbook_name = nil
+      self.class.include_resource_dsl_module(new_resource)
     end
 
     def whyrun_mode?
@@ -119,11 +121,11 @@ class Chef
       check_resource_semantics!
 
       # user-defined LWRPs may include unsafe load_current_resource methods that cannot be run in whyrun mode
-      if !whyrun_mode? || whyrun_supported?
+      if whyrun_mode? && !whyrun_supported?
+        events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
+      else
         load_current_resource
         events.resource_current_state_loaded(@new_resource, @action, @current_resource)
-      elsif whyrun_mode? && !whyrun_supported?
-        events.resource_current_state_load_bypassed(@new_resource, @action, @current_resource)
       end
 
       define_resource_requirements
@@ -136,9 +138,7 @@ class Chef
       # we can't execute the action.
       # in non-whyrun mode, this will still cause the action to be
       # executed normally.
-      if whyrun_supported? && !requirements.action_blocked?(@action)
-        send("action_#{@action}")
-      elsif whyrun_mode?
+      if whyrun_mode? && (!whyrun_supported? || requirements.action_blocked?(@action))
         events.resource_bypassed(@new_resource, @action, self)
       else
         send("action_#{@action}")
@@ -175,6 +175,62 @@ class Chef
       converge_actions.add_action(descriptions, &block)
     end
 
+    #
+    # Handle patchy convergence safely.
+    #
+    # - Does *not* call the block if the current_resource's properties match
+    #   the properties the user specified on the resource.
+    # - Calls the block if current_resource does not exist
+    # - Calls the block if the user has specified any properties in the resource
+    #   whose values are *different* from current_resource.
+    # - Does *not* call the block if why-run is enabled (just prints out text).
+    # - Prints out automatic green text saying what properties have changed.
+    #
+    # @param properties An optional list of property names (symbols). If not
+    #   specified, `new_resource.class.state_properties` will be used.
+    # @param converge_block The block to do the converging in.
+    #
+    # @return [Boolean] whether the block was executed.
+    #
+    def converge_if_changed(*properties, &converge_block)
+      if !converge_block
+        raise ArgumentError, "converge_if_changed must be passed a block!"
+      end
+
+      properties = new_resource.class.state_properties.map { |p| p.name } if properties.empty?
+      properties = properties.map { |p| p.to_sym }
+      if current_resource
+        # Collect the list of modified properties
+        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(", ")}.")
+          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})" }
+        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}"
+          else
+            created << "  set #{property.to_s.ljust(property_size)} to #{new_resource.send(property).inspect} (default value)"
+          end
+        end
+
+        converge_by([ "create #{new_resource.identity}" ] + created, &converge_block)
+      end
+      true
+    end
+
     def self.provides(short_name, opts={}, &block)
       Chef.provider_handler_map.set(short_name, self, opts, &block)
     end
@@ -183,6 +239,157 @@ class Chef
       Chef::ProviderResolver.new(node, resource, :nothing).provided_by?(self)
     end
 
+    #
+    # Include attributes, public and protected methods from this Resource in
+    # the provider.
+    #
+    # If this is set to true, delegate methods are included in the provider so
+    # that you can call (for example) `attrname` and it will call
+    # `new_resource.attrname`.
+    #
+    # The actual include does not happen until the first time the Provider
+    # is instantiated (so that we don't have to worry about load order issues).
+    #
+    # @param include_resource_dsl [Boolean] Whether to include resource DSL or
+    #   not (defaults to `false`).
+    #
+    def self.include_resource_dsl(include_resource_dsl)
+      @include_resource_dsl = include_resource_dsl
+    end
+
+    # Create the resource DSL module that forwards resource methods to new_resource
+    #
+    # @api private
+    def self.include_resource_dsl_module(resource)
+      if @include_resource_dsl && !defined?(@included_resource_dsl_module)
+        provider_class = self
+        @included_resource_dsl_module = Module.new do
+          extend Forwardable
+          define_singleton_method(:to_s) { "forwarder module for #{provider_class}" }
+          define_singleton_method(:inspect) { to_s }
+          # Add a delegator for each explicit property that will get the *current* value
+          # of the property by default instead of the *actual* value.
+          resource.class.properties.each do |name, property|
+            class_eval(<<-EOM, __FILE__, __LINE__)
+              def #{name}(*args, &block)
+                # If no arguments were passed, we process "get" by defaulting
+                # the value to current_resource, not new_resource. This helps
+                # avoid issues where resources accidentally overwrite perfectly
+                # valid stuff with default values.
+                if args.empty? && !block
+                  if !new_resource.property_is_set?(__method__) && current_resource
+                    return current_resource.public_send(__method__)
+                  end
+                end
+                new_resource.public_send(__method__, *args, &block)
+              end
+            EOM
+          end
+          dsl_methods =
+             resource.class.public_instance_methods +
+             resource.class.protected_instance_methods -
+             provider_class.instance_methods -
+             resource.class.properties.keys
+          def_delegators(:new_resource, *dsl_methods)
+        end
+        include @included_resource_dsl_module
+      end
+    end
+
+    # Enables inline evaluation of resources in provider actions.
+    #
+    # Without this option, any resources declared inside the Provider are added
+    # to the resource collection after the current position at the time the
+    # action is executed. Because they are added to the primary resource
+    # collection for the chef run, they can notify other resources outside
+    # the Provider, and potentially be notified by resources outside the Provider
+    # (but this is complicated by the fact that they don't exist until the
+    # provider executes). In this mode, it is impossible to correctly set the
+    # updated_by_last_action flag on the parent Provider resource, since it
+    # executes and returns before its component resources are run.
+    #
+    # With this option enabled, each action creates a temporary run_context
+    # with its own resource collection, evaluates the action's code in that
+    # context, and then converges the resources created. If any resources
+    # were updated, then this provider's new_resource will be marked updated.
+    #
+    # In this mode, resources created within the Provider cannot interact with
+    # external resources via notifies, though notifications to other
+    # resources within the Provider will work. Delayed notifications are executed
+    # at the conclusion of the provider's action, *not* at the end of the
+    # main chef run.
+    #
+    # This mode of evaluation is experimental, but is believed to be a better
+    # set of tradeoffs than the append-after mode, so it will likely become
+    # the default in a future major release of Chef.
+    #
+    def self.use_inline_resources
+      extend InlineResources::ClassMethods
+      include InlineResources
+    end
+
+    # Chef::Provider::InlineResources
+    # Implementation of inline resource convergence for providers. See
+    # Provider.use_inline_resources for a longer explanation.
+    #
+    # This code is restricted to a module so that it can be selectively
+    # applied to providers on an opt-in basis.
+    #
+    # @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)
+      end
+
+      # Class methods for InlineResources. Overrides the `action` DSL method
+      # with one that enables inline resource convergence.
+      #
+      # @api private
+      module ClassMethods
+        # Defines an action method on the provider, running the block to
+        # 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.
+          begin
+            class_eval <<-EOM, __FILE__, __LINE__+1
+              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
+              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
+          end
+          # We put the action in its own method so that super() works.
+          define_method("compile_action_#{name}", &block)
+        end
+      end
+
+      require 'chef/dsl/recipe'
+      include Chef::DSL::Recipe::FullDSL
+    end
+
     protected
 
     def converge_actions
@@ -200,19 +407,21 @@ class Chef
       # manipulating notifies.
 
       converge_by ("evaluate block and run any associated actions") do
-        saved_run_context = @run_context
-        @run_context = @run_context.dup
-        @run_context.resource_collection = Chef::ResourceCollection.new
-        instance_eval(&block)
-        Chef::Runner.new(@run_context).converge
-        @run_context = saved_run_context
+        saved_run_context = run_context
+        begin
+          @run_context = run_context.create_child
+          instance_eval(&block)
+          Chef::Runner.new(run_context).converge
+        ensure
+          @run_context = saved_run_context
+        end
       end
     end
 
     module DeprecatedLWRPClass
       def const_missing(class_name)
         if deprecated_constants[class_name.to_sym]
-          Chef::Log.deprecation("Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
+          Chef.log_deprecation("Using an LWRP provider by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::ProviderResolver.new(node, resource, action) instead.")
           deprecated_constants[class_name.to_sym]
         else
           raise NameError, "uninitialized constant Chef::Provider::#{class_name}"

data/lib/chef/provider/batch.rb

@@ -28,6 +28,14 @@ class Chef
         super(new_resource, run_context, '.bat')
       end
 
+      def command
+        basepath = is_forced_32bit ? wow64_directory : run_context.node.kernel.os_info.system_directory
+
+        interpreter_path = Chef::Util::PathHelper.join(basepath, interpreter)
+
+        "\"#{interpreter_path}\" #{flags} \"#{script_file.path}\""
+      end
+
       def flags
         @new_resource.flags.nil? ? '/c' : new_resource.flags + ' /c'
       end

data/lib/chef/provider/deploy.rb

@@ -201,7 +201,7 @@ class Chef
 
           converge_by("execute migration command #{@new_resource.migration_command}") do
             Chef::Log.info "#{@new_resource} migrating #{@new_resource.user} with environment #{env_info}"
-            run_command(run_options(:command => @new_resource.migration_command, :cwd=>release_path, :log_level => :info))
+            shell_out!(@new_resource.migration_command,run_options(:cwd=>release_path, :log_level => :info))
           end
         end
       end
@@ -221,7 +221,7 @@ class Chef
           else
             converge_by("restart app using command #{@new_resource.restart_command}") do
               Chef::Log.info("#{@new_resource} restarting app")
-              run_command(run_options(:command => @new_resource.restart_command, :cwd => @new_resource.current_path))
+              shell_out!(@new_resource.restart_command,run_options(:cwd=>@new_resource.current_path))
             end
           end
         end
@@ -373,11 +373,9 @@ class Chef
       end
 
       def gem_resource_collection_runner
-        gems_collection = Chef::ResourceCollection.new
-        gem_packages.each { |rbgem| gems_collection.insert(rbgem) }
-        gems_run_context = run_context.dup
-        gems_run_context.resource_collection = gems_collection
-        Chef::Runner.new(gems_run_context)
+        child_context = run_context.create_child
+        gem_packages.each { |rbgem| child_context.resource_collection.insert(rbgem) }
+        Chef::Runner.new(child_context)
       end
 
       def gem_packages

data/lib/chef/provider/directory.rb

@@ -64,7 +64,13 @@ class Chef
               is_parent_writable = lambda do |base_dir|
                 base_dir = ::File.dirname(base_dir)
                 if ::File.exists?(base_dir)
-                  Chef::FileAccessControl.writable?(base_dir)
+                  if Chef::FileAccessControl.writable?(base_dir)
+                    true
+                  elsif Chef::Util::PathHelper.is_sip_path?(base_dir, node)
+                    Chef::Util::PathHelper.writable_sip_path?(base_dir)
+                  else
+                    false
+                  end
                 else
                   is_parent_writable.call(base_dir)
                 end
@@ -74,7 +80,13 @@ class Chef
               # in why run mode & parent directory does not exist no permissions check is required
               # If not in why run, permissions must be valid and we rely on prior assertion that dir exists
               if !whyrun_mode? || ::File.exists?(parent_directory)
-                Chef::FileAccessControl.writable?(parent_directory)
+                if Chef::FileAccessControl.writable?(parent_directory)
+                  true
+                elsif Chef::Util::PathHelper.is_sip_path?(parent_directory, node)
+                  Chef::Util::PathHelper.writable_sip_path?(@new_resource.path)
+                else
+                  false
+                end
               else
                 true
               end

data/lib/chef/provider/dsc_resource.rb

@@ -59,9 +59,7 @@ class Chef
           a.block_action!
         end
         requirements.assert(:run) do |a|
-          a.assertion {
-            meta_configuration['RefreshMode'] == 'Disabled'
-          }
+          a.assertion { dsc_refresh_mode_disabled? }
           err = ["The LCM must have its RefreshMode set to Disabled. "]
           a.failure_message Chef::Exceptions::ProviderNotFound, err.join(' ')
           a.whyrun err + ["Assuming a previous resource sets the RefreshMode."]
@@ -85,6 +83,10 @@ class Chef
       def supports_dsc_invoke_resource?
         run_context && Chef::Platform.supports_dsc_invoke_resource?(node)
       end
+      
+      def dsc_refresh_mode_disabled?
+        Chef::Platform.dsc_refresh_mode_disabled?(node)
+      end
 
       def generate_description
         @converge_description
@@ -153,12 +155,6 @@ class Chef
         cmdlet.run!
       end
 
-      def meta_configuration
-        cmdlet = Chef::Util::Powershell::Cmdlet.new(node, "Get-DscLocalConfigurationManager", :object)
-        result = cmdlet.run!
-        result.return_value
-      end
-
     end
   end
 end

data/lib/chef/provider/group/pw.rb

@@ -109,7 +109,7 @@ class Chef
           else
             # Append is not set so we're resetting the membership of
             # the group to the given members.
-            members_to_be_added = @new_resource.members
+            members_to_be_added = @new_resource.members.dup
             @current_resource.members.each do |member|
               # No need to re-add a member if it's present in the new
               # list of members

data/lib/chef/provider/ifconfig.rb

@@ -194,7 +194,7 @@ class Chef
 
       private
       def add_command
-        command = "ifconfig #{@new_resource.device} #{@new_resource.name}"
+        command = "ifconfig #{@new_resource.device} #{@new_resource.target}"
         command << " netmask #{@new_resource.mask}" if @new_resource.mask
         command << " metric #{@new_resource.metric}" if @new_resource.metric
         command << " mtu #{@new_resource.mtu}" if @new_resource.mtu
@@ -202,7 +202,7 @@ class Chef
       end
 
       def enable_command
-        command = "ifconfig #{@new_resource.device} #{@new_resource.name}"
+        command = "ifconfig #{@new_resource.device} #{@new_resource.target}"
         command << " netmask #{@new_resource.mask}" if @new_resource.mask
         command << " metric #{@new_resource.metric}" if @new_resource.metric
         command << " mtu #{@new_resource.mtu}" if @new_resource.mtu

data/lib/chef/provider/lwrp_base.rb

@@ -28,52 +28,10 @@ class Chef
     # Base class from which LWRP providers inherit.
     class LWRPBase < Provider
 
-      # Chef::Provider::LWRPBase::InlineResources
-      # Implementation of inline resource convergence for LWRP providers. See
-      # Provider::LWRPBase.use_inline_resources for a longer explanation.
-      #
-      # This code is restricted to a module so that it can be selectively
-      # applied to providers on an opt-in basis.
-      module InlineResources
-
-        # Class methods for InlineResources. Overrides the `action` DSL method
-        # with one that enables inline resource convergence.
-        module ClassMethods
-          # Defines an action method on the provider, using
-          # recipe_eval_with_update_check to execute the given block.
-          def action(name, &block)
-            define_method("action_#{name}") do
-              recipe_eval_with_update_check(&block)
-            end
-          end
-        end
-
-        # Executes the given block in a temporary run_context with its own
-        # resource collection. After the block is executed, any resources
-        # declared inside are converged, and if any are updated, the
-        # new_resource will be marked updated.
-        def recipe_eval_with_update_check(&block)
-          saved_run_context = @run_context
-          temp_run_context = @run_context.dup
-          @run_context = temp_run_context
-          @run_context.resource_collection = Chef::ResourceCollection.new
-
-          return_value = instance_eval(&block)
-          Chef::Runner.new(@run_context).converge
-          return_value
-        ensure
-          @run_context = saved_run_context
-          if temp_run_context.resource_collection.any? {|r| r.updated? }
-            new_resource.updated_by_last_action(true)
-          end
-        end
-
-      end
-
       include Chef::DSL::Recipe
 
       # These were previously provided by Chef::Mixin::RecipeDefinitionDSLCore.
-      # They are not included by its replacment, Chef::DSL::Recipe, but
+      # They are not included by its replacement, Chef::DSL::Recipe, but
       # they may be used in existing LWRPs.
       include Chef::DSL::PlatformIntrospection
       include Chef::DSL::DataQuery
@@ -122,38 +80,6 @@ class Chef
           provider_class
         end
 
-        # Enables inline evaluation of resources in provider actions.
-        #
-        # Without this option, any resources declared inside the LWRP are added
-        # to the resource collection after the current position at the time the
-        # action is executed. Because they are added to the primary resource
-        # collection for the chef run, they can notify other resources outside
-        # the LWRP, and potentially be notified by resources outside the LWRP
-        # (but this is complicated by the fact that they don't exist until the
-        # provider executes). In this mode, it is impossible to correctly set the
-        # updated_by_last_action flag on the parent LWRP resource, since it
-        # executes and returns before its component resources are run.
-        #
-        # With this option enabled, each action creates a temporary run_context
-        # with its own resource collection, evaluates the action's code in that
-        # context, and then converges the resources created. If any resources
-        # were updated, then this provider's new_resource will be marked updated.
-        #
-        # In this mode, resources created within the LWRP cannot interact with
-        # external resources via notifies, though notifications to other
-        # resources within the LWRP will work. Delayed notifications are executed
-        # at the conclusion of the provider's action, *not* at the end of the
-        # main chef run.
-        #
-        # This mode of evaluation is experimental, but is believed to be a better
-        # set of tradeoffs than the append-after mode, so it will likely become
-        # the default in a future major release of Chef.
-        #
-        def use_inline_resources
-          extend InlineResources::ClassMethods
-          include InlineResources
-        end
-
         # DSL for defining a provider's actions.
         def action(name, &block)
           define_method("action_#{name}") do