adjustment

Author: LukasAud

lib/puppet/provider/base_dsc_lite/powershell.rb

@@ -4,6 +4,7 @@
 require 'json'
 require_relative '../../../puppet_x/puppetlabs/dsc_lite/powershell_hash_formatter'
 require 'puppet/pops/evaluator/deferred_resolver'
+require 'puppet/node/facts'
 
 Puppet::Type.type(:base_dsc_lite).provide(:powershell) do
   confine feature: :pwshlib
@@ -40,6 +41,26 @@ def self.resolve_deferred(value)
     Puppet::Pops::Evaluator::DeferredResolver.resolve(value, compiler)
   end
 
+  # Add these helpers near the top of the provider (same file), outside methods:
+  def deep_contains_deferred?(obj)
+    case obj
+    when Puppet::Pops::Evaluator::DeferredValue
+      true
+    when Hash
+      obj.any? { |k, v| deep_contains_deferred?(k) || deep_contains_deferred?(v) }
+    when Array
+      obj.any? { |v| deep_contains_deferred?(v) }
+    when Puppet::Pops::Types::PSensitiveType::Sensitive
+      begin
+        deep_contains_deferred?(obj.unwrap)
+      rescue
+        false
+      end
+    else
+      false
+    end
+  end
+
   def self.upgrade_message
     Puppet.warning DSC_LITE_MODULE_PUPPET_UPGRADE_MSG unless @upgrade_warning_issued
     @upgrade_warning_issued = true
@@ -174,6 +195,58 @@ def ps_script_content(mode)
   def self.ps_script_content(mode, resource, provider)
     dsc_invoke_method = mode
     @param_hash = resource
+
+    # Resolve any remaining Deferred values (especially nested inside :properties)
+    begin
+      props_param = resource.parameters[:properties]
+      if props_param
+        props_val = props_param.value
+
+        if deep_contains_deferred?(props_val)
+          # Prefer compiler-based resolution when available
+          compiler = Puppet.lookup(:compiler) { nil }
+
+          if compiler
+            resolved = Puppet::Pops::Evaluator::DeferredResolver.resolve(props_val, compiler)
+            # Re-assign resolved properties back to the resource
+            resource[:properties] = resolved
+          else
+            # Fallback: resolve across the whole catalog in place
+            # Try to get facts via indirection when possible; otherwise synthesize from Facter.
+            facts = nil
+            if resource.catalog.respond_to?(:host) && resource.catalog.host
+              # May return nil if facts are not stored; that’s fine, we’ll synthesize.
+              facts = begin
+                        Puppet::Node::Facts.indirection.find(resource.catalog.host)
+                      rescue
+                        nil
+                      end
+            end
+            facts ||= Puppet::Node::Facts.new(
+              Facter.value(:fqdn) || Facter.value(:hostname) || 'localhost',
+              Facter.to_hash,
+            )
+
+            # Determine environment instance when available
+            env = if resource.catalog.respond_to?(:environment_instance)
+                    resource.catalog.environment_instance
+                  else
+                    Puppet.lookup(:current_environment) { nil }
+                  end
+
+            # Resolve all Deferreds in the catalog (safe, official API)
+            Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(facts, resource.catalog, env, true)
+
+            # Refresh our local value after resolution (in case it changed)
+            props_param = resource.parameters[:properties]
+            resource[:properties] = props_param.value if props_param
+          end
+        end
+      end
+    rescue => e
+      raise Puppet::Error, "DSC_lite: failed to resolve Deferred values in `properties`: #{e.class}: #{e.message}"
+    end
+
     template_name = resource.generic_dsc ? '/invoke_generic_dsc_resource.ps1.erb' : '/invoke_dsc_resource.ps1.erb'
     file = File.new(template_path + template_name, encoding: Encoding::UTF_8)
     template = ERB.new(file.read, trim_mode: '-')

spec/acceptance/deferred_spec.rb

@@ -8,16 +8,13 @@ def read_fixture(name)
 end
 
 def read_win_file_if_exists(path)
-  # Use a script block with literals; avoid $variables to prevent transport/quoting expansion
-  # Also keep exit 0 regardless of existence so run_shell doesn't raise.
   ps = %{& { if (Test-Path -LiteralPath '#{path}') { Get-Content -Raw -LiteralPath '#{path}' } else { '<<<FILE_NOT_FOUND>>>' } } }
   r  = run_shell(%(powershell.exe -NoProfile -NonInteractive -Command "#{ps}"))
   body = (r.stdout || '').to_s
   exists = !body.include?('<<<FILE_NOT_FOUND>>>')
   { exists: exists, content: exists ? body : '' }
 end
 
-# ---- NEW: wrappers that always pass the required flags ----
 def puppet_flags
   [
     '--preprocess_deferred', 'true',
@@ -34,22 +31,16 @@ def apply_manifest_with_flags(manifest, opts = {})
 def idempotent_apply_with_flags(manifest, opts = {})
   idempotent_apply(manifest, opts.merge(puppet_options: puppet_flags))
 end
-# ----------------------------------------------------------
-
 RSpec.configure do |config|
   config.before(:all) do
-    # Ensure Deferred values are preprocessed before provider runs (Puppet 8 default is false)
     run_shell('puppet config set preprocess_deferred true --section agent')
-    # Ensure JSON catalog serialization (avoids PSON issues with Deferred)
     run_shell('puppet config set preferred_serialization_format json --section agent')
 
-    # Assert settings for clear diagnostics in CI logs
     pp  = run_shell('puppet config print preprocess_deferred --section agent').stdout.strip
     fmt = run_shell('puppet config print preferred_serialization_format --section agent').stdout.strip
     raise 'preprocess_deferred not true on agent!' unless pp.casecmp('true').zero?
     raise 'preferred_serialization_format not json on agent!' unless fmt.casecmp('json').zero?
 
-    # Extra visibility: show puppet version & confdir in logs
     run_shell('puppet --version')
     run_shell('puppet config print confdir')
   end
@@ -58,21 +49,16 @@ def idempotent_apply_with_flags(manifest, opts = {})
 describe 'deferred values with dsc_lite' do
   let(:control_manifest)         { read_fixture('01_file_deferred.pp') }
   let(:dsc_deferred_direct)      { read_fixture('02_dsc_deferred_direct.pp') }
-  let(:dsc_deferred_inline)      { read_fixture('02b_dsc_deferred_inline.pp') } # NEW
+  let(:dsc_deferred_inline)      { read_fixture('02b_dsc_deferred_inline.pp') }
   let(:dsc_deferred_stringified) { read_fixture('03a_dsc_deferred_stringified.pp') }
   let(:dsc_deferred_bad_unwrap)  { read_fixture('03b_dsc_deferred_bad_unwrap.pp') }
 
-  # ---- NEW: diagnostic example to prove effective settings for this process ----
-  it '00: confirms preprocess_deferred=true and JSON are active in the current apply context' do
-    print_pp = <<-PP
-      notify { "preprocess_deferred=#{Puppet.lookup(:settings).value('preprocess_deferred')}": }
-      notify { "preferred_serialization_format=#{Puppet.lookup(:settings).value('preferred_serialization_format')}": }
-    PP
-    res = apply_manifest_with_flags(print_pp)
-    expect(res.stdout).to match(%r{preprocess_deferred=true}i)
-    expect(res.stdout).to match(%r{preferred_serialization_format=json}i)
+  it '00: confirms preprocess_deferred=true and JSON are active in this context' do
+    pp_out  = run_shell('puppet config print preprocess_deferred --section agent').stdout.strip
+    fmt_out = run_shell('puppet config print preferred_serialization_format --section agent').stdout.strip
+    expect(pp_out.downcase).to eq('true')
+    expect(fmt_out.downcase).to eq('json')
   end
-  # ------------------------------------------------------------------------------
 
   it 'control (01): native file + Deferred resolves to hello-file' do
     result = idempotent_apply_with_flags(control_manifest)
@@ -95,7 +81,6 @@ def idempotent_apply_with_flags(manifest, opts = {})
     end
   end
 
-  # NEW 02b: inline Deferred on the DSC property (no variable intermediary)
   it '02b: passing Deferred inline to DSC resolves to hello-dsc-inline (otherwise flag bug)' do
     apply = apply_manifest_with_flags(dsc_deferred_inline)
     out   = read_win_file_if_exists('C:/Temp/from_dsc_inline.txt')