ruby-pwsh 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb7a2c9a103865f74de54ae3a977a70382a2b18ff2e1f8f830b25ef50f4ba1d2
-  data.tar.gz: 7ca9acbd7478367673a8f761a0b51ddf5f0359246b3ca72f7fe9b8e4c3da34a6
+  metadata.gz: e217873cdddb9b32ba467e0a9f5de6977c04b11a1c0788613dda6181e96a62bd
+  data.tar.gz: 8dc82dfad8869d7c632ba3d902b4e22c375aeb5988f84e359269163da885b604
 SHA512:
-  metadata.gz: 830c6e92076e50675f1ce02445f9fd9952545987af24e152bb164b11223d35d47d3619c997bf51b9b09293b22d69d2c832e689f59cfbad1118663203af374046
-  data.tar.gz: 5e107bcb95cc294f2c421d565c3376b21a7272b4bd4e4c32684f4481577398e2fa54c5005f8e6d990a7d9ffebf2db5eca5dbdb7eba2b2c7ddb2660ca65315f04
+  metadata.gz: a7e02f1cee48fa49316c133268a16f9bc3b8f195927834854c81eee134cdb7056710cd1be04eaf992ca036aa2b014175d06ebf8684eef6354ef8d10a07a62e31
+  data.tar.gz: da78f276002b67faf3716ce0b8157fe3cf0edbbeb5da3ae1145c3ed696e386838285138fdd0c75b8a592b677b7631c66ce07355a25788dee58354af0ecdd9eaa

data/README.md

@@ -86,6 +86,10 @@ The following platforms are supported:
 - RedHat
 - Ubuntu
 
+## Limitations
+
+- When PowerShell [Script Block Logging](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_logging_windows?view=powershell-7.4#enabling-script-block-logging) is enabled, data marked as sensitive in your manifest may appear in these logs as plain text. It is **highly recommended**, by both Puppet and Microsoft, that you also enable [Protected Event Logging](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_logging_windows?view=powershell-7.4#protected-event-logging) alongside this to encrypt the logs to protect this information.
+
 ## License
 
 This codebase is licensed under Apache 2.0. However, the open source dependencies included in this codebase might be subject to other software licenses such as AGPL, GPL2.0, and MIT.

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

@@ -15,6 +15,7 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
     @cached_query_results = []
     @cached_test_results = []
     @logon_failures = []
+    @timeout = nil # default timeout, ps_manager.execute is expecting nil by default..
     super
   end
 
@@ -44,6 +45,7 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
   # @param context [Object] the Puppet runtime context to operate in and send feedback to
   # @param resources [Hash] the hash of the resource to canonicalize from either manifest or invocation
   # @return [Hash] returns a hash representing the current state of the object, if it exists
+  # rubocop:disable Metrics/BlockLength, Metrics/MethodLength
   def canonicalize(context, resources)
     canonicalized_resources = []
     resources.collect do |r|
@@ -83,9 +85,18 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
             downcased_result.each do |key, value|
               # Canonicalize to the manifest value unless the downcased strings match and the attribute is not an enum:
               # - When the values don't match at all, the manifest value is desired;
-              # - When the values match case insensitively but the attribute is an enum, prefer the casing of the manifest enum.
-              # - When the values match case insensitively and the attribute is not an enum, prefer the casing from invoke_get_method
-              canonicalized[key] = r[key] unless same?(value, downcased_resource[key]) && !enum_attributes(context).include?(key)
+              # - When the values match case insensitively but the attribute is an enum, and the casing from invoke_get_method
+              #   is not int the enum, prefer the casing of the manifest enum.
+              # - When the values match case insensitively and the attribute is not an enum, or is an enum and invoke_get_method casing
+              #   is in the enum, prefer the casing from invoke_get_method
+              is_enum = enum_attributes(context).include?(key)
+              canonicalized_value_in_enum = if is_enum
+                                              enum_values(context, key).include?(canonicalized[key])
+                                            else
+                                              false
+                                            end
+              match_insensitively = same?(value, downcased_resource[key])
+              canonicalized[key] = r[key] unless match_insensitively && (canonicalized_value_in_enum || !is_enum)
               canonicalized.delete(key) unless downcased_resource.key?(key)
             end
             # Cache the actually canonicalized resource separately
@@ -104,6 +115,7 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
     context.debug("Canonicalized Resources: #{canonicalized_resources}")
     canonicalized_resources
   end
+  # rubocop:enable Metrics/BlockLength, Metrics/MethodLength
 
   # Attempts to retrieve an instance of the DSC resource, invoking the `Get` method and passing any
   # namevars as the Properties to Invoke-DscResource. The result object, if any, is compared to the
@@ -240,18 +252,22 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
       context.err('Logon credentials are invalid')
       return nil
     end
+    specify_dsc_timeout(name_hash)
     resource = invocable_resource(props, context, method)
     script_content = ps_script_content(resource)
+    context.debug("Invoke-DSC Timeout: #{@timeout} milliseconds") if @timeout
     context.debug("Script:\n #{redact_secrets(script_content)}")
-    output = ps_manager.execute(remove_secret_identifiers(script_content))[:stdout]
+    output = ps_manager.execute(remove_secret_identifiers(script_content), @timeout)
 
-    if output.nil?
-      context.err('Nothing returned')
+    if output[:stdout].nil?
+      message = 'Nothing returned.'
+      message += " #{output[:errormessage]}" if output[:errormessage]&.match?(/PowerShell module timeout \(\d+ ms\) exceeded while executing/)
+      context.err(message)
       return nil
     end
 
     begin
-      data = JSON.parse(output)
+      data = JSON.parse(output[:stdout])
     rescue StandardError => e
       context.err(e)
       return nil
@@ -284,6 +300,18 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
     data
   end
 
+  # Sets the @timeout instance variable.
+  # @param name_hash [Hash] the hash of namevars to be passed as properties to `Invoke-DscResource`
+  # The @timeout variable is set to the value of name_hash[:dsc_timeout] in milliseconds
+  # If name_hash[:dsc_timeout] is nil, @timeout is not changed.
+  # If @timeout is already set to a value other than nil,
+  # it is changed only if it's different from name_hash[:dsc_timeout]..
+  def specify_dsc_timeout(name_hash)
+    return unless name_hash[:dsc_timeout] && (@timeout.nil? || @timeout != name_hash[:dsc_timeout])
+
+    @timeout = name_hash[:dsc_timeout] * 1000
+  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
@@ -299,24 +327,16 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
       # 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
+      # if no error, assume successful invocation and break
+      break if data['errormessage'].nil?
+
+      # notify of failed retry
+      context.notice("Attempt #{try} of #{max_retry_count} failed.")
+      # return if error does not match expceted error, or all retries exhausted
+      return context.err(data['errormessage']) unless data['errormessage'].match?(error_matcher) && try < max_retry_count
+
+      # else, retry
+      next
     end
     data
   end
@@ -348,7 +368,7 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
   # @param context [Object] the Puppet runtime context to operate in and send feedback to
   # @param name_hash [Hash] the hash of namevars to be passed as properties to `Invoke-DscResource`
   # @return [Hash] returns a hash representing the DSC resource munged to the representation the Puppet Type expects
-  def invoke_get_method(context, name_hash)
+  def invoke_get_method(context, name_hash) # rubocop:disable Metrics/AbcSize
     context.debug("retrieving #{name_hash.inspect}")
 
     query_props = name_hash.select { |k, v| mandatory_get_attributes(context).include?(k) || (k == :dsc_psdscrunascredential && !v.nil?) }
@@ -391,6 +411,8 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
     # If a resource is found, it's present, so refill this Puppet-only key
     data[:name] = name_hash[:name]
 
+    data = stringify_nil_attributes(context, data)
+
     # Have to check for this to avoid a weird canonicalization warning
     # The Resource API calls canonicalize against the current state which
     # will lead to dsc_ensure being set to absent in the name_hash even if
@@ -660,6 +682,20 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
     context.type.attributes.select { |_attribute, properties| properties[:mandatory_for_set] }.keys
   end
 
+  # Parses the DSC resource type definition to retrieve the names of any attributes which are specified as required strings
+  # This is used to ensure that any nil values are converted to empty strings to match puppets expected value
+  # @param context [Object] the Puppet runtime context to operate in and send feedback to
+  # @param data [Hash] the hash of properties returned from the DSC resource
+  # @return [Hash] returns a data hash with any nil values converted to empty strings
+  def stringify_nil_attributes(context, data)
+    nil_attributes = data.select { |_name, value| value.nil? }.keys
+    nil_attributes.each do |nil_attr|
+      attribute_type = context.type.attributes[nil_attr][:type]
+      data[nil_attr] = '' if (attribute_type.include?('Enum[') && enum_values(context, nil_attr).include?('')) || attribute_type == 'String'
+    end
+    data
+  end
+
   # Parses the DSC resource type definition to retrieve the names of any attributes which are specified as namevars
   #
   # @param context [Object] the Puppet runtime context to operate in and send feedback to
@@ -686,6 +722,28 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
     context.type.attributes.select { |_name, properties| properties[:type].include?('Enum[') }.keys
   end
 
+  # Parses the DSC resource type definition to retrieve the values of any attributes which are specified as enums
+  #
+  # @param context [Object] the Puppet runtime context to operate in and send feedback to
+  # @param attribute [String] the enum attribute to retrieve the allowed values from
+  # @return [Array] returns an array of attribute names as symbols which are enums
+  def enum_values(context, attribute)
+    # Get the attribute's type string for the given key
+    type_string = context.type.attributes[attribute][:type]
+
+    # Return an empty array if the key doesn't have an Enum type or doesn't exist
+    return [] unless type_string&.include?('Enum[')
+
+    # Extract the enum values from the type string
+    enum_content = type_string.match(/Enum\[(.*?)\]/)&.[](1)
+
+    # Return an empty array if we couldn't find the enum values
+    return [] if enum_content.nil?
+
+    # Return an array of the enum values, stripped of extra whitespace and quote marks
+    enum_content.split(',').map { |val| val.strip.delete('\'') }
+  end
+
   # Look through a fully formatted string, replacing all instances where a value matches the formatted properties
   # of an instantiated variable with references to the variable instead. This allows us to pass complex and nested
   # CIM instances to the Invoke-DscResource parameter hash without constructing them *in* the hash.
@@ -1035,6 +1093,10 @@ class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
   def ps_manager
     debug_output = Puppet::Util::Log.level == :debug
     # TODO: Allow you to specify an alternate path, either to pwsh generally or a specific pwsh path.
-    Pwsh::Manager.instance(Pwsh::Manager.powershell_path, Pwsh::Manager.powershell_args, debug: debug_output)
+    if Pwsh::Util.on_windows?
+      Pwsh::Manager.instance(Pwsh::Manager.powershell_path, Pwsh::Manager.powershell_args, debug: debug_output)
+    else
+      Pwsh::Manager.instance(Pwsh::Manager.pwsh_path, Pwsh::Manager.pwsh_args, debug: debug_output)
+    end
   end
 end

data/lib/puppet/provider/dsc_base_provider/invoke_dsc_resource_functions.ps1

@@ -123,4 +123,4 @@ Function ConvertTo-CanonicalResult {
 
   # Output the final result
   $ResultObject
-}
+}

data/lib/pwsh/util.rb

@@ -7,12 +7,12 @@ module Pwsh
     module_function
 
     # Verifies whether or not the current context is running on a Windows node.
+    # Implementation copied from `facets`: https://github.com/rubyworks/facets/blob/main/lib/standard/facets/rbconfig.rb
     #
     # @return [Bool] true if on windows
     def on_windows?
-      # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
-      # library uses that to test what platform it's on.
-      !!File::ALT_SEPARATOR
+      host_os = RbConfig::CONFIG['host_os']
+      !!(host_os =~ /mswin|mingw/)
     end
 
     # Verify paths specified are valid directories which exist.

data/lib/pwsh/version.rb

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

data/lib/pwsh.rb

@@ -380,7 +380,7 @@ module Pwsh
           pwsh_paths << File.join(path, 'pwsh.exe') if File.exist?(File.join(path, 'pwsh.exe'))
         end
       else
-        search_paths.split(File::PATH_SEPARATOR).each do |path|
+        search_paths.split(':').each do |path|
           pwsh_paths << File.join(path, 'pwsh') if File.exist?(File.join(path, 'pwsh'))
         end
       end

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

@@ -179,6 +179,8 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
             end
 
             it 'treats the manifest value as canonical' do
+              expect(context).to receive(:type).and_return(type)
+              expect(type).to receive(:attributes).and_return({ dsc_property: { type: "Enum['Dword']" } })
               expect(canonicalized_resource.first[:dsc_property]).to eq('Dword')
             end
           end
@@ -539,7 +541,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
     context 'when the invocation script returns data without errors' do
       before do
-        allow(ps_manager).to receive(:execute).with(script).and_return({ stdout: 'DSC Data' })
+        allow(ps_manager).to receive(:execute).with(script, nil).and_return({ stdout: 'DSC Data' })
         allow(JSON).to receive(:parse).with('DSC Data').and_return(parsed_invocation_data)
         allow(Puppet::Pops::Time::Timestamp).to receive(:parse).with('2100-01-01').and_return('TimeStamp:2100-01-01')
         allow(provider).to receive(:fetch_cached_hashes).and_return([])
@@ -657,15 +659,15 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     context 'when the DSC invocation errors' do
       it 'writes an error and returns nil' do
         expect(provider).not_to receive(:logon_failed_already?)
-        expect(ps_manager).to receive(:execute).with(script).and_return({ stdout: nil })
-        expect(context).to receive(:err).with('Nothing returned')
+        expect(ps_manager).to receive(:execute).with(script, nil).and_return({ stdout: nil })
+        expect(context).to receive(:err).with('Nothing returned.')
         expect(result).to be_nil
       end
     end
 
     context 'when handling DateTimes' do
       before do
-        allow(ps_manager).to receive(:execute).with(script).and_return({ stdout: 'DSC Data' })
+        allow(ps_manager).to receive(:execute).with(script, nil).and_return({ stdout: 'DSC Data' })
         allow(JSON).to receive(:parse).with('DSC Data').and_return(parsed_invocation_data)
         allow(provider).to receive(:fetch_cached_hashes).and_return([])
       end
@@ -717,7 +719,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
       context 'when the credential is invalid' do
         before do
           allow(provider).to receive(:logon_failed_already?).and_return(false)
-          allow(ps_manager).to receive(:execute).with(script).and_return({ stdout: 'DSC Data' })
+          allow(ps_manager).to receive(:execute).with(script, nil).and_return({ stdout: 'DSC Data' })
           allow(JSON).to receive(:parse).with('DSC Data').and_return({ 'errormessage' => dsc_logon_failure_error })
           allow(context).to receive(:err).with(name_hash[:name], puppet_logon_failure_error)
         end
@@ -781,7 +783,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     context 'when the invocation script returns nil' do
       it 'errors via context but does not raise' do
         expect(ps_manager).to receive(:execute).and_return({ stdout: nil })
-        expect(context).to receive(:err).with('Nothing returned')
+        expect(context).to receive(:err).with('Nothing returned.')
         expect { result }.not_to raise_error
       end
     end
@@ -812,9 +814,9 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
                                                .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(context).to receive(:notice).with(/Retrying: attempt [1-5] 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(:notice).with(/Attempt [1-5] 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
@@ -827,14 +829,35 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
         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(:notice).with(/Attempt 1 of 5 failed/).once
         expect(context).to receive(:err).with(/Some unexpected error/)
         expect(result).to be_nil
       end
     end
 
+    context 'when a dsc_timeout is specified' do
+      let(:should_hash) { name.merge(dsc_timeout: 5) }
+      let(:apply_props_with_timeout) { { dsc_name: 'foo', dsc_timeout: 5 } }
+      let(:resource_with_timeout) { "Resource: #{apply_props_with_timeout}" }
+      let(:script_with_timeout) { "Script: #{apply_props_with_timeout}" }
+
+      before do
+        allow(provider).to receive(:invocable_resource).with(apply_props_with_timeout, context, 'set').and_return(resource_with_timeout)
+        allow(provider).to receive(:ps_script_content).with(resource_with_timeout).and_return(script_with_timeout)
+        allow(provider).to receive(:remove_secret_identifiers).with(script_with_timeout).and_return(script_with_timeout)
+      end
+
+      it 'sets @timeout and passes it to ps_manager.execute' do
+        provider.instance_variable_set(:@timeout, nil)
+        expect(ps_manager).to receive(:execute).with(script_with_timeout, 5000).and_return({ stdout: '{"in_desired_state": true, "errormessage": null}' })
+        provider.invoke_set_method(context, name, should_hash)
+        expect(provider.instance_variable_get(:@timeout)).to eq(5000)
+      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}' })
+        expect(ps_manager).to receive(:execute).with("Script: #{apply_props}", nil).and_return({ stdout: '{"in_desired_state": true, "errormessage": null}' })
         expect(context).not_to receive(:err)
         expect(result).to eq({ 'in_desired_state' => true, 'errormessage' => nil })
       end
@@ -2107,21 +2130,44 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
   end
 
   describe '.ps_manager' do
-    before do
-      allow(Pwsh::Manager).to receive(:powershell_path).and_return('pwsh')
-      allow(Pwsh::Manager).to receive(:powershell_args).and_return('args')
-    end
+    describe '.ps_manager on non-Windows' do
+      before do
+        allow(Pwsh::Util).to receive(:on_windows?).and_return(false)
+        allow(Pwsh::Manager).to receive(:pwsh_path).and_return('pwsh')
+        allow(Pwsh::Manager).to receive(:pwsh_args).and_return('args')
+      end
+
+      it 'Initializes an instance of the Pwsh::Manager' do
+        expect(Puppet::Util::Log).to receive(:level).and_return(:normal)
+        expect(Pwsh::Manager).to receive(:instance).with('pwsh', 'args', debug: false)
+        expect { provider.ps_manager }.not_to raise_error
+      end
 
-    it 'Initializes an instance of the Pwsh::Manager' do
-      expect(Puppet::Util::Log).to receive(:level).and_return(:normal)
-      expect(Pwsh::Manager).to receive(:instance).with('pwsh', 'args', debug: false)
-      expect { provider.ps_manager }.not_to raise_error
+      it 'passes debug as true if Puppet::Util::Log.level is debug' do
+        expect(Puppet::Util::Log).to receive(:level).and_return(:debug)
+        expect(Pwsh::Manager).to receive(:instance).with('pwsh', 'args', debug: true)
+        expect { provider.ps_manager }.not_to raise_error
+      end
     end
 
-    it 'passes debug as true if Puppet::Util::Log.level is debug' do
-      expect(Puppet::Util::Log).to receive(:level).and_return(:debug)
-      expect(Pwsh::Manager).to receive(:instance).with('pwsh', 'args', debug: true)
-      expect { provider.ps_manager }.not_to raise_error
+    describe '.ps_manager on Windows' do
+      before do
+        allow(Pwsh::Util).to receive(:on_windows?).and_return(true)
+        allow(Pwsh::Manager).to receive(:powershell_path).and_return('pwsh')
+        allow(Pwsh::Manager).to receive(:powershell_args).and_return('args')
+      end
+
+      it 'Initializes an instance of the Pwsh::Manager' do
+        expect(Puppet::Util::Log).to receive(:level).and_return(:normal)
+        expect(Pwsh::Manager).to receive(:instance).with('pwsh', 'args', debug: false)
+        expect { provider.ps_manager }.not_to raise_error
+      end
+
+      it 'passes debug as true if Puppet::Util::Log.level is debug' do
+        expect(Puppet::Util::Log).to receive(:level).and_return(:debug)
+        expect(Pwsh::Manager).to receive(:instance).with('pwsh', 'args', debug: true)
+        expect { provider.ps_manager }.not_to raise_error
+      end
     end
   end
 end

metadata

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