ruby-pwsh 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd8ad4546d9fbdc7bf62c17f8132adb9647e311e9e3319b22b5161f924fd94c3
-  data.tar.gz: c607771ae691c4593b839cc1134d3e0fcc15b0a454eef93a3b146301d13b3411
+  metadata.gz: eb7a2c9a103865f74de54ae3a977a70382a2b18ff2e1f8f830b25ef50f4ba1d2
+  data.tar.gz: 7ca9acbd7478367673a8f761a0b51ddf5f0359246b3ca72f7fe9b8e4c3da34a6
 SHA512:
-  metadata.gz: e8efb9f23a1fe2302369938416d08e463c4c5e088712dac293b10f0e8abc09431f91057039f95f918382e4775b932da4ab270901591f58d834a01c1d784d4fe6
-  data.tar.gz: 788c3c601d46c37478b41abe5a068eac7da7c0912ec71f703841f4d462a3363d2c613bbeb8356b6a38b21a3870eec0d567e4bfa2d2892a40aadd1e4a62dc38e1
+  metadata.gz: 830c6e92076e50675f1ce02445f9fd9952545987af24e152bb164b11223d35d47d3619c997bf51b9b09293b22d69d2c832e689f59cfbad1118663203af374046
+  data.tar.gz: 5e107bcb95cc294f2c421d565c3376b21a7272b4bd4e4c32684f4481577398e2fa54c5005f8e6d990a7d9ffebf2db5eca5dbdb7eba2b2c7ddb2660ca65315f04

data/.rubocop.yml

@@ -18,6 +18,9 @@ AllCops:
 Style/ClassAndModuleChildren:
   Enabled: false
 
+Layout/LineLength:
+  Max: 196
+
 ####################################################
 # Cops below here due for deprecation
 ####################################################

data/lib/puppet/provider/dsc_base_provider/dsc_base_provider.rb

@@ -5,7 +5,7 @@ require 'ruby-pwsh'
 require 'pathname'
 require 'json'
 
-class Puppet::Provider::DscBaseProvider
+class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
   # Initializes the provider, preparing the instance variables which cache:
   # - the canonicalized resources across calls
   # - query results
@@ -244,6 +244,7 @@ class Puppet::Provider::DscBaseProvider
     script_content = ps_script_content(resource)
     context.debug("Script:\n #{redact_secrets(script_content)}")
     output = ps_manager.execute(remove_secret_identifiers(script_content))[:stdout]
+
     if output.nil?
       context.err('Nothing returned')
       return nil
@@ -256,8 +257,10 @@ class Puppet::Provider::DscBaseProvider
       return nil
     end
     context.debug("raw data received: #{data.inspect}")
+    collision_error_matcher = /The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked/
 
     error = data['errormessage']
+
     unless error.nil? || error.empty?
       # NB: We should have a way to stop processing this resource *now* without blowing up the whole Puppet run
       # Raising an error stops processing but blows things up while context.err alerts but continues to process
@@ -267,6 +270,11 @@ class Puppet::Provider::DscBaseProvider
         @logon_failures << name_hash[:dsc_psdscrunascredential].dup
         # This is a hack to handle the query cache to prevent a second lookup
         @cached_query_results << name_hash # if fetch_cached_hashes(@cached_query_results, [data]).empty?
+      elsif error.match?(collision_error_matcher)
+        context.notice('Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour.')
+        retry_invoke_dsc_resource(context, 5, 60, collision_error_matcher) do
+          data = ps_manager.execute(remove_secret_identifiers(script_content))[:stdout]
+        end
       else
         context.err(error)
       end
@@ -276,6 +284,43 @@ class Puppet::Provider::DscBaseProvider
     data
   end
 
+  # Retries Invoke-DscResource when returned error matches error regex supplied as param.
+  # @param context [Object] the Puppet runtime context to operate in and send feedback to
+  # @param max_retry_count [Int] max number of times to retry Invoke-DscResource
+  # @param retry_wait_interval_secs [Int] Time delay between retries
+  # @param error_matcher [String] the regex pattern to match with error
+  def retry_invoke_dsc_resource(context, max_retry_count, retry_wait_interval_secs, error_matcher)
+    try = 0
+    while try < max_retry_count
+      try += 1
+      # notify and wait for retry interval
+      context.notice("Sleeping for #{retry_wait_interval_secs} seconds.")
+      sleep retry_wait_interval_secs
+      # notify and retry
+      context.notice("Retrying: attempt #{try} of #{max_retry_count}.")
+      data = JSON.parse(yield)
+      # if no error, break
+      if data['errormessage'].nil?
+        break
+      # check if error matches error matcher supplied
+      elsif data['errormessage'].match?(error_matcher)
+        # if last attempt, return error
+        if try == max_retry_count
+          context.notice("Attempt #{try} of #{max_retry_count} failed. No more retries.")
+          # all attempts failed, raise error
+          return context.err(data['errormessage'])
+        end
+        # if not last attempt, notify, continue and retry
+        context.notice("Attempt #{try} of #{max_retry_count} failed.")
+        next
+      else
+        # if we get an unexpected error, return
+        return context.err(data['errormessage'])
+      end
+    end
+    data
+  end
+
   # Determine if the DSC Resource is in the desired state, invoking the `Test` method unless it's
   #   already been run for the resource, in which case reuse the result instead of checking for each
   #   property. This behavior is only triggered if the validation_mode is set to resource; by default
@@ -666,7 +711,7 @@ class Puppet::Provider::DscBaseProvider
   # @param resource [Hash] a hash with the information needed to run `Invoke-DscResource`
   # @return [String] A multi-line string which sets the PSModulePath at the system level
   def munge_psmodulepath(resource)
-    vendor_path = resource[:vendored_modules_path].tr('/', '\\')
+    vendor_path = resource[:vendored_modules_path]&.tr('/', '\\')
     <<~MUNGE_PSMODULEPATH.strip
       $UnmungedPSModulePath = [System.Environment]::GetEnvironmentVariable('PSModulePath','machine')
       $MungedPSModulePath = $env:PSModulePath + ';#{vendor_path}'

data/lib/pwsh/version.rb

@@ -2,5 +2,5 @@
 
 module Pwsh
   # The version of the ruby-pwsh gem
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/spec/spec_helper.rb

@@ -1,5 +1,30 @@
 # frozen_string_literal: true
 
+if ENV['COVERAGE'] == 'yes'
+  begin
+    require 'simplecov'
+    require 'simplecov-console'
+
+    SimpleCov.formatters = [
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::Console
+    ]
+
+    SimpleCov.start do
+      track_files 'lib/**/*.rb'
+
+      add_filter '/spec'
+      add_filter 'lib/pwsh/version.rb'
+
+      # do not track vendored files
+      add_filter '/vendor'
+      add_filter '/.vendor'
+    end
+  rescue LoadError
+    raise 'Add the simplecov & simplecov-console gems to Gemfile to enable this task'
+  end
+end
+
 require 'bundler/setup'
 require 'ruby-pwsh'
 

data/spec/unit/puppet/provider/dsc_base_provider/dsc_base_provider_spec.rb

@@ -2,23 +2,24 @@
 
 require 'spec_helper'
 require 'puppet/type'
+require 'puppet/resource_api'
 require 'puppet/provider/dsc_base_provider/dsc_base_provider'
 require 'json'
 
 RSpec.describe Puppet::Provider::DscBaseProvider do
   subject(:provider) { described_class.new }
 
-  let(:context) { instance_double(Puppet::ResourceApi::PuppetContext) }
-  let(:type) { instance_double(Puppet::ResourceApi::TypeDefinition) }
+  let(:context) { instance_double(Puppet::ResourceApi::BaseContext, 'context') }
+  let(:type) { instance_double(Puppet::ResourceApi::TypeDefinition, 'typedef') }
   let(:ps_manager) { instance_double(Pwsh::Manager) }
   let(:execute_response) { { stdout: nil, stderr: nil, exitcode: 0 } }
 
   # Reset the caches after each run
   after do
-    described_class.instance_variable_set(:@cached_canonicalized_resource, [])
-    described_class.instance_variable_set(:@cached_query_results, [])
-    described_class.instance_variable_set(:@cached_test_results, [])
-    described_class.instance_variable_set(:@logon_failures, [])
+    provider.instance_variable_set(:@cached_canonicalized_resource, [])
+    provider.instance_variable_set(:@cached_query_results, [])
+    provider.instance_variable_set(:@cached_test_results, [])
+    provider.instance_variable_set(:@logon_failures, [])
   end
 
   describe '.initialize' do
@@ -28,27 +29,30 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'initializes the cached_canonicalized_resource instance variable' do
-      expect(described_class.instance_variable_get(:@cached_canonicalized_resource)).to eq([])
+      expect(provider.instance_variable_get(:@cached_canonicalized_resource)).to eq([])
     end
 
     it 'initializes the cached_query_results instance variable' do
-      expect(described_class.instance_variable_get(:@cached_query_results)).to eq([])
+      expect(provider.instance_variable_get(:@cached_query_results)).to eq([])
     end
 
     it 'initializes the cached_test_results instance variable' do
-      expect(described_class.instance_variable_get(:@cached_test_results)).to eq([])
+      expect(provider.instance_variable_get(:@cached_test_results)).to eq([])
     end
 
     it 'initializes the logon_failures instance variable' do
-      expect(described_class.instance_variable_get(:@logon_failures)).to eq([])
+      expect(provider.instance_variable_get(:@logon_failures)).to eq([])
     end
   end
 
   describe '.cached_test_results' do
     let(:cache_value) { %w[foo bar] }
 
+    before do
+      provider.instance_variable_set(:@cached_test_results, cache_value)
+    end
+
     it 'returns the value of the @cached_test_results instance variable' do
-      described_class.instance_variable_set(:@cached_test_results, cache_value)
       expect(provider.cached_test_results).to eq(cache_value)
     end
   end
@@ -237,11 +241,11 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
   describe '.get' do
     after do
-      described_class.instance_variable_set(:@cached_canonicalized_resource, [])
+      provider.instance_variable_set(:@cached_canonicalized_resource, [])
     end
 
     it 'checks the cached results, returning if one exists for the specified names' do
-      described_class.instance_variable_set(:@cached_canonicalized_resource, [])
+      provider.instance_variable_set(:@cached_canonicalized_resource, [])
       allow(context).to receive(:debug)
       expect(provider).to receive(:fetch_cached_hashes).with([], [{ name: 'foo' }]).and_return([{ name: 'foo', property: 'bar' }])
       expect(provider).not_to receive(:invoke_get_method)
@@ -249,7 +253,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'adds mandatory properties to the name hash when calling invoke_get_method' do
-      described_class.instance_variable_set(:@cached_canonicalized_resource, [{ name: 'foo', property: 'bar', dsc_some_parameter: 'baz' }])
+      provider.instance_variable_set(:@cached_canonicalized_resource, [{ name: 'foo', property: 'bar', dsc_some_parameter: 'baz' }])
       allow(context).to receive(:debug)
       expect(provider).to receive(:fetch_cached_hashes).with([], [{ name: 'foo' }]).and_return([])
       expect(provider).to receive(:namevar_attributes).and_return([:name]).exactly(3).times
@@ -530,7 +534,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     after do
-      described_class.instance_variable_set(:@cached_query_results, nil)
+      provider.instance_variable_set(:@cached_query_results, [])
     end
 
     context 'when the invocation script returns data without errors' do
@@ -557,7 +561,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
       it 'caches the result' do
         expect { result }.not_to raise_error
-        expect(described_class.instance_variable_get(:@cached_query_results)).to eq([result])
+        expect(provider.instance_variable_get(:@cached_query_results)).to eq([result])
       end
 
       it 'removes unrelated properties from the result' do
@@ -719,7 +723,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
         end
 
         after do
-          described_class.instance_variable_set(:@logon_failures, [])
+          provider.instance_variable_set(:@logon_failures, [])
         end
 
         it 'errors specifically for a logon failure and returns nil' do
@@ -728,12 +732,12 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
         it 'caches the logon failure' do
           expect { result }.not_to raise_error
-          expect(described_class.instance_variable_get(:@logon_failures)).to eq([credential_hash])
+          expect(provider.instance_variable_get(:@logon_failures)).to eq([credential_hash])
         end
 
         it 'caches the query results' do
           expect { result }.not_to raise_error
-          expect(described_class.instance_variable_get(:@cached_query_results)).to eq([name_hash])
+          expect(provider.instance_variable_get(:@cached_query_results)).to eq([name_hash])
         end
       end
 
@@ -790,6 +794,44 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
       end
     end
 
+    context 'when the invocation script errors with a collision' do
+      it 'writes a notice via context and applies successfully on retry' do
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with(/Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour./).once
+        expect(context).to receive(:notice).with('Sleeping for 60 seconds.').twice
+        expect(context).to receive(:notice).with(/Retrying: attempt [1-2] of 5/).twice
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with('Attempt 1 of 5 failed.')
+        allow(provider).to receive(:sleep)
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": null}' })
+        expect { result }.not_to raise_error
+      end
+
+      it 'writes a error via context and fails to apply when all retry attempts used' do
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+                                               .exactly(5).times
+        expect(context).to receive(:notice).with(/Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour./).once
+        expect(context).to receive(:notice).with('Sleeping for 60 seconds.').exactly(5).times
+        expect(context).to receive(:notice).with(/Retrying: attempt [1-6] of 5/).exactly(5).times
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with(/Attempt [1-6] of 5 failed/).exactly(5).times
+        expect(context).to receive(:err).with(/The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked/)
+        allow(provider).to receive(:sleep)
+        expect(result).to be_nil
+      end
+
+      it 'writes an error via context and fails to apply when encountering an unexpected error' do
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with(/Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour./).once
+        expect(context).to receive(:notice).with('Sleeping for 60 seconds.').once
+        expect(context).to receive(:notice).with(/Retrying: attempt 1 of 5/).once
+        allow(provider).to receive(:sleep)
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "Some unexpected error"}' }).once
+        expect(context).to receive(:err).with(/Some unexpected error/)
+        expect(result).to be_nil
+      end
+    end
+
     context 'when the invocation script returns data without errors' do
       it 'filters for the correct properties to invoke and returns the results' do
         expect(ps_manager).to receive(:execute).with("Script: #{apply_props}").and_return({ stdout: '{"in_desired_state": true, "errormessage": null}' })
@@ -981,11 +1023,11 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
   end
 
   describe '.invoke_test_method' do
-    subject(:result) { provider.invoke_test_method(context, name, expect(subject).to) }
+    subject(:result) { provider.invoke_test_method(context, name, should_hash) }
 
     let(:name) { { name: 'foo', dsc_name: 'bar' } }
-    let(:should) { name.merge(dsc_ensure: 'present') }
-    let(:test_properties) { expect(subject).to.reject { |k, _v| k == :name } }
+    let(:should_hash) { name.merge(dsc_ensure: 'present') }
+    let(:test_properties) { should_hash.reject { |k, _v| k == :name } }
     let(:invoke_dsc_resource_data) { nil }
 
     before do
@@ -995,7 +1037,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     after do
-      described_class.instance_variable_set(:@cached_test_results, [])
+      provider.instance_variable_set(:@cached_test_results, [])
     end
 
     context 'when something went wrong calling Invoke-DscResource' do
@@ -1043,7 +1085,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
   describe '.instantiated_variables' do
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     it 'sets the instantiated_variables instance variable to {} if not initialized' do
@@ -1051,20 +1093,20 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'returns the instantiated_variables instance variable if already initialized' do
-      described_class.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
+      provider.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
       expect(provider.instantiated_variables).to eq({ foo: 'bar' })
     end
   end
 
   describe '.clear_instantiated_variables!' do
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     it 'sets the instantiated_variables instance variable to {}' do
-      described_class.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
+      provider.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
       expect { provider.clear_instantiated_variables! }.not_to raise_error
-      expect(described_class.instance_variable_get(:@instantiated_variables)).to eq({})
+      expect(provider.instance_variable_get(:@instantiated_variables)).to eq({})
     end
   end
 
@@ -1087,16 +1129,16 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
       end
 
       after do
-        described_class.instance_variable_set(:@logon_failures, [])
+        provider.instance_variable_set(:@logon_failures, [])
       end
 
       it 'returns false if there have been no failed logons with the username/password combination' do
-        described_class.instance_variable_set(:@logon_failures, [bad_credential_hash])
+        provider.instance_variable_set(:@logon_failures, [bad_credential_hash])
         expect(provider.logon_failed_already?(good_credential_hash)).to be(false)
       end
 
       it 'returns true if the username/password specified are found in the logon_failures instance variable' do
-        described_class.instance_variable_set(:@logon_failures, [good_credential_hash, bad_credential_hash])
+        provider.instance_variable_set(:@logon_failures, [good_credential_hash, bad_credential_hash])
         expect(provider.logon_failed_already?(bad_credential_hash)).to be(true)
       end
     end
@@ -1437,16 +1479,18 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     context 'when the resource does not have the dscmeta_resource_implementation key' do
       let(:test_resource) { {} }
 
-      it 'returns nil' do
-        expect(result).to be_nil
+      it 'sets $UnmungedPSModulePath to the current PSModulePath' do
+        # since https://github.com/puppetlabs/ruby-pwsh/pull/261 we load vendored path for MOF resources as well
+        expect(result).to match(/\$UnmungedPSModulePath = .+GetEnvironmentVariable.+PSModulePath.+machine/)
       end
     end
 
     context "when the resource's dscmeta_resource_implementation is not 'Class'" do
       let(:test_resource) { { dscmeta_resource_implementation: 'MOF' } }
 
-      it 'returns nil' do
-        expect(result).to be_nil
+      # since https://github.com/puppetlabs/ruby-pwsh/pull/261 we load vendored path for MOF resources as well
+      it 'sets $UnmungedPSModulePath to the current PSModulePath' do
+        expect(result).to match(/\$UnmungedPSModulePath = .+GetEnvironmentVariable.+PSModulePath.+machine/)
       end
     end
 
@@ -1510,7 +1554,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
       end
 
       after do
-        described_class.instance_variable_set(:@instantiated_variables, [])
+        provider.instance_variable_set(:@instantiated_variables, [])
       end
 
       it 'writes the ruby representation of the credentials as the value of a key named for the new variable into the instantiated_variables cache' do
@@ -1543,7 +1587,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     subject(:result) { provider.prepare_cim_instances(test_resource) }
 
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     context 'when a cim instance is passed without nested cim instances' do
@@ -1652,7 +1696,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
   describe '.format_ciminstance' do
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     it 'defines and returns a new cim instance as a PowerShell variable, passing the class name and property hash' do
@@ -1668,7 +1712,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'interpolates variables in the case of a cim instance containing a nested instance' do
-      described_class.instance_variable_set(:@instantiated_variables, { 'SomeVariable' => { 'bar' => 'ope' } })
+      provider.instance_variable_set(:@instantiated_variables, { 'SomeVariable' => { 'bar' => 'ope' } })
       property_hash = { 'foo' => { 'bar' => 'ope' } }
       expect(provider.format_ciminstance('foo', 'SomeClass', property_hash)).to match(/@\{'foo' = \$SomeVariable\}/)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-pwsh
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-13 00:00:00.000000000 Z
+date: 2024-01-31 00:00:00.000000000 Z
 dependencies: []
 description: PowerShell code manager for ruby.
 email: