expand logging

Author: LukasAud

lib/puppet/provider/base_dsc_lite/powershell.rb

@@ -2,6 +2,7 @@
 
 require 'pathname'
 require 'json'
+require 'puppet/pops/evaluator/deferred_resolver'
 require_relative '../../../puppet_x/puppetlabs/dsc_lite/powershell_hash_formatter'
 
 Puppet::Type.type(:base_dsc_lite).provide(:powershell) do
@@ -40,6 +41,23 @@ def self.vendored_modules_path
     File.expand_path(Pathname.new(__FILE__).dirname + '../../../' + 'puppet_x/dsc_resources')
   end
 
+  def force_resolve_catalog_deferred!
+    cat = resource&.catalog
+    return unless cat
+    facts = Puppet.lookup(:facts) { nil }
+    env   = if cat.respond_to?(:environment_instance)
+              cat.environment_instance
+            else
+              Puppet.lookup(:current_environment) { nil }
+            end
+    begin
+      Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(facts, cat, env, true)
+      Puppet.notice('DSC PROVIDER SENTINEL → resolve_and_replace invoked')
+    rescue => e
+      Puppet.notice("DSC PROVIDER resolve_and_replace error: #{e.class}: #{e.message}")
+    end
+  end
+
   def dsc_parameters
     resource.parameters_with_value.select do |p|
       p.name.to_s.include? 'dsc_'
@@ -66,6 +84,8 @@ def ps_manager
   end
 
   def exists?
+    Puppet.notice("DSC PROVIDER SENTINEL → #{__FILE__}")
+    force_resolve_catalog_deferred!
     timeout = set_timeout
     Puppet.debug "Dsc Timeout: #{timeout} milliseconds"
     version = Facter.value(:powershell_version)
@@ -95,6 +115,8 @@ def exists?
   end
 
   def create
+    Puppet.notice("DSC PROVIDER SENTINEL → #{__FILE__}")
+    force_resolve_catalog_deferred!
     timeout = set_timeout
     Puppet.debug "Dsc Timeout: #{timeout} milliseconds"
     script_content = ps_script_content('set')

lib/puppet/type/dsc.rb

@@ -107,15 +107,32 @@ def change_to_s(currentvalue, newvalue)
     end
 
     munge do |value|
-      # If the compiler is present (compile-time), resolve any direct/nested Deferred values.
+      Puppet.notice("DSC TYPE SENTINEL → #{__FILE__}")
       compiler = Puppet.lookup(:compiler) { nil }
-      resolved = if compiler
-                   Puppet::Pops::Evaluator::DeferredResolver.resolve(value, compiler)
-                 else
-                   value
-                 end
+      if compiler
+        begin
+          resolved = Puppet::Pops::Evaluator::DeferredResolver.resolve(value, compiler)
+        rescue => e
+          Puppet.notice("DSC TYPE resolve() error: #{e.class}: #{e.message}")
+          resolved = value
+        end
+      else
+        Puppet.notice('DSC TYPE SENTINEL → no compiler available during munge')
+        resolved = value
+      end
+
+      # Quick check: did any Deferred remain?
+      def contains_deferred?(x)
+        case x
+        when Hash  then x.any? { |k, v| contains_deferred?(k) || contains_deferred?(v) }
+        when Array then x.any? { |v| contains_deferred?(v) }
+        else x && x.class.name.to_s.include?('Deferred')
+        end
+      end
+      if contains_deferred?(resolved)
+        Puppet.notice('DSC TYPE SENTINEL → properties still contains Deferred AFTER resolve()')
+      end
 
-      # Preserve your existing sensitive handling on the resolved hash
       PuppetX::DscLite::TypeHelpers.munge_sensitive_hash(resolved)
     end
   end