patching

Author: LukasAud

lib/puppet/provider/base_dsc_lite/powershell.rb

@@ -81,14 +81,10 @@ def resolve_deferred_values!
     Puppet.notice('DSC PROVIDER → Resolving deferred values in properties')
 
     begin
-      # Get the facts that are available on the agent
-      facts = Puppet.lookup(:facts) { nil }
-
-      # Create a minimal evaluation context for deferred resolution
-      # This approach uses Puppet's built-in deferred resolution mechanism
-      resolved_properties = resolve_deferred_recursively(current_properties, facts)
+      # Resolve deferred values directly using the properties hash
+      resolved_properties = manually_resolve_deferred_values(current_properties)
 
-      # Update the parameter value with the resolved version
+      # Update the resource with resolved properties
       resource.parameters[:properties].value = resolved_properties
 
       # Verify resolution worked
@@ -99,70 +95,66 @@ def resolve_deferred_values!
       end
     rescue => e
       Puppet.warning("DSC PROVIDER → Error resolving deferred values: #{e.class}: #{e.message}")
+      Puppet.debug("DSC PROVIDER → Error backtrace: #{e.backtrace.join("\n")}")
       # Continue with unresolved values - they will be stringified but at least won't crash
     end
   end
 
-  # Check if a value contains any deferred values (recursively)
-  def contains_deferred_values?(value)
+  # Recursively resolve deferred values in a data structure
+  def manually_resolve_deferred_values(value)
     case value
     when Hash
-      value.any? { |k, v| contains_deferred_values?(k) || contains_deferred_values?(v) }
-    when Array
-      value.any? { |v| contains_deferred_values?(v) }
-    else
-      # Check if this is a Deferred object
-      value && value.class.name.include?('Deferred')
-    end
-  end
-
-  # Recursively resolve deferred values using Puppet's deferred function mechanism
-  def resolve_deferred_recursively(value, facts)
-    case value
-    when Hash
-      result = {}
+      resolved_hash = {}
       value.each do |k, v|
-        result[resolve_deferred_recursively(k, facts)] = resolve_deferred_recursively(v, facts)
+        resolved_key = manually_resolve_deferred_values(k)
+        resolved_value = manually_resolve_deferred_values(v)
+        resolved_hash[resolved_key] = resolved_value
       end
-      result
+      resolved_hash
     when Array
-      value.map { |v| resolve_deferred_recursively(v, facts) }
+      value.map { |v| manually_resolve_deferred_values(v) }
     else
-      # If this is a Deferred object, resolve it
-      if value && value.class.name.include?('Deferred')
-        resolve_single_deferred(value, facts)
-      else
-        value
+      # Handle different types of deferred objects
+      if value.is_a?(Puppet::Pops::Evaluator::DeferredValue)
+        # DeferredValue objects have a @proc instance variable we can call
+        proc = value.instance_variable_get(:@proc)
+        return proc.call if proc && proc.respond_to?(:call)
+
+        Puppet.debug('DSC PROVIDER → DeferredValue has no callable proc')
+        return value.to_s
+
+      elsif value && value.class.name.include?('Deferred')
+        # For other Deferred types, try standard resolution
+        if value.respond_to?(:name)
+          begin
+            return Puppet::Pops::Evaluator::DeferredResolver.resolve(value.name, nil, {})
+          rescue => e
+            Puppet.debug("DSC PROVIDER → Failed to resolve Deferred object: #{e.message}")
+            return value.to_s
+          end
+        else
+          Puppet.debug('DSC PROVIDER → Deferred object has no name method')
+          return value.to_s
+        end
       end
+
+      # Return the value unchanged if it's not deferred
+      value
     end
   end
 
-  # Resolve a single Deferred object
-  def resolve_single_deferred(deferred_value, _facts)
-    # For Deferred objects, we need to call the actual function with the parameters
-    # This mimics what Puppet does during normal deferred resolution
-
-    function_name = deferred_value.name
-    arguments = deferred_value.arguments
-
-    # Call the function with the provided arguments
-    # This uses Puppet's function loading mechanism
-    loaders = Puppet.lookup(:loaders)
-    function_loader = loaders.private_environment_loader || loaders.static_loader
-    function = function_loader.load(:function, function_name)
-
-    if function
-      # Execute the function with the arguments
-      result = function.call({}, *arguments)
-      Puppet.debug("DSC PROVIDER → Resolved Deferred('#{function_name}', #{arguments.inspect}) → #{result.inspect}")
-      result
+  # Check if a value contains any deferred values (recursively)
+  def contains_deferred_values?(value)
+    case value
+    when Hash
+      value.any? { |k, v| contains_deferred_values?(k) || contains_deferred_values?(v) }
+    when Array
+      value.any? { |v| contains_deferred_values?(v) }
     else
-      Puppet.warning("DSC PROVIDER → Could not load function '#{function_name}' for deferred resolution")
-      deferred_value
+      # Check if this is a Deferred object or DeferredValue
+      value && (value.class.name.include?('Deferred') ||
+                value.is_a?(Puppet::Pops::Evaluator::DeferredValue))
     end
-  rescue => e
-    Puppet.warning("DSC PROVIDER → Error resolving Deferred('#{function_name}'): #{e.message}")
-    deferred_value
   end
 
   # ---------------------------