ruby-pwsh 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37a20d5c79da4ea0b065cb85afc8e99933128576ef73c759a9f8113b7f738eed
-  data.tar.gz: 9da59c07a8037eee9bb03591726ed83e4909b95009579b362fb49a4d2e4ac171
+  metadata.gz: 164dc89d750a5544dd4c100bd2166c0fe9d26447d5636bb18b0eec7d8dfc142f
+  data.tar.gz: bdf317f119bd2e5a7261a711a2a5c4721feda199a955feb5265af07c6f94d8d8
 SHA512:
-  metadata.gz: 760bbbdd326042ff79e4e0f28bbfe48447ddc17fb6968f569ce1c5d75848a83e3b3042022250fb309d98124d97580c9ad1a7a9a8a629aadbbdc57b7de7718f60
-  data.tar.gz: 1c57dec6a7bd3db1e4b32adfd0e61abb996157317fa2f74f20110f246a3daf8f6302aa0569aef07e863299e9a8ba126631b89f9df3055f5b013a8c720ff308e0
+  metadata.gz: 8430d204e301ce7577148a95d37a8581b3e0d37da1c3e97fcb5dce3c3a2b66601b651dd48ef3a2810d802d09cf28579dfc986712bf407e54ecb3ca8f23ab9283
+  data.tar.gz: ed31dd3ec848dc4c7fd108ee040c5b39e532ea50fe406ba8f98dfb6bb2cf5c804b0d758c393ead8b560785d34717a629380e346f24baae6963e34094889c6fdc

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org).
 
+## [0.6.0](https://github.com/puppetlabs/ruby-pwsh/tree/0.6.0) (2020-11-24)
+
+[Full Changelog](https://github.com/puppetlabs/ruby-pwsh/compare/0.5.1...0.6.0)
+
+### Added
+
+- \(GH-81\) Handle parameters in the dsc base provider [\#62](https://github.com/puppetlabs/ruby-pwsh/pull/62) ([michaeltlombardi](https://github.com/michaeltlombardi))
+- \(GH-74\) Remove special handling for ensure in the dsc base provider [\#61](https://github.com/puppetlabs/ruby-pwsh/pull/61) ([michaeltlombardi](https://github.com/michaeltlombardi))
+- \(GH-59\) Refactor away from Simple Provider [\#60](https://github.com/puppetlabs/ruby-pwsh/pull/60) ([michaeltlombardi](https://github.com/michaeltlombardi))
+
+### Fixed
+
+- \(GH-57\) Handle datetimes in dsc [\#58](https://github.com/puppetlabs/ruby-pwsh/pull/58) ([michaeltlombardi](https://github.com/michaeltlombardi))
+- \(GH-55\) Handle intentionally empty arrays [\#56](https://github.com/puppetlabs/ruby-pwsh/pull/56) ([michaeltlombardi](https://github.com/michaeltlombardi))
+
 ## [0.5.1](https://github.com/puppetlabs/ruby-pwsh/tree/0.5.1) (2020-09-25)
 
 [Full Changelog](https://github.com/puppetlabs/ruby-pwsh/compare/0.5.0...0.5.1)

data/appveyor.yml

@@ -2,7 +2,7 @@
 version: 1.1.x.{build}
 branches:
   only:
-    - master
+    - main
     - release
 clone_depth: 10
 environment:

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

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require 'puppet/resource_api/simple_provider'
 require 'securerandom'
 require 'ruby-pwsh'
 require 'pathname'
 require 'json'
 
-class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
+class Puppet::Provider::DscBaseProvider
   # Initializes the provider, preparing the class variables which cache:
   # - the canonicalized resources across calls
   # - query results
@@ -15,6 +14,7 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     @@cached_canonicalized_resource = []
     @@cached_query_results = []
     @@logon_failures = []
+    super
   end
 
   # Look through a cache to retrieve the hashes specified, if they have been cached.
@@ -109,6 +109,77 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     end
   end
 
+  # Determines whether a resource is ensurable and which message to write (create, update, or delete),
+  # then passes the appropriate values along to the various sub-methods which themselves call the Set
+  # method of Invoke-DscResource. Implementation borrowed directly from the Resource API Simple Provider
+  #
+  # @param context [Object] the Puppet runtime context to operate in and send feedback to
+  # @param changes [Hash] the hash of whose key is the name_hash and value is the is and should hashes
+  def set(context, changes)
+    changes.each do |name, change|
+      is = change.key?(:is) ? change[:is] : (get(context, [name]) || []).find { |r| r[:name] == name }
+      context.type.check_schema(is) unless change.key?(:is)
+
+      should = change[:should]
+
+      name_hash = if context.type.namevars.length > 1
+                    # pass a name_hash containing the values of all namevars
+                    name_hash = {}
+                    context.type.namevars.each do |namevar|
+                      name_hash[namevar] = change[:should][namevar]
+                    end
+                    name_hash
+                  else
+                    name
+                  end
+
+      # for compatibility sake, we use dsc_ensure instead of ensure, so context.type.ensurable? does not work
+      if !context.type.attributes.key?(:dsc_ensure)
+        is = create_absent(:name, name) if is.nil?
+        should = create_absent(:name, name) if should.nil?
+
+        # HACK: If the DSC Resource is ensurable but doesn't report a default value
+        # for ensure, we assume it to be `Present` - this is the most common pattern.
+        should_ensure = should[:dsc_ensure].nil? ? 'Present' : should[:dsc_ensure].to_s
+        is_ensure = is[:dsc_ensure].to_s
+
+        if is_ensure == 'Absent' && should_ensure == 'Present'
+          context.creating(name) do
+            create(context, name_hash, should)
+          end
+        elsif is_ensure == 'Present' && should_ensure == 'Present'
+          context.updating(name) do
+            update(context, name_hash, should)
+          end
+        elsif is_ensure == 'Present' && should_ensure == 'Absent'
+          context.deleting(name) do
+            delete(context, name_hash)
+          end
+        end
+      else
+        context.updating(name) do
+          update(context, name_hash, should)
+        end
+      end
+    end
+  end
+
+  # Creates a hash with the name / name_hash and sets dsc_ensure to absent for comparison
+  # purposes; this handles cases where the resource isn't found on the node.
+  #
+  # @param namevar [Object] the name of the variable being used for the resource name
+  # @param title [Hash] the hash of namevar properties and their values
+  # @return [Hash] returns a hash representing the absent state of the resource
+  def create_absent(namevar, title)
+    result = if title.is_a? Hash
+               title.dup
+             else
+               { namevar => title }
+             end
+    result[:dsc_ensure] = 'Absent'
+    result
+  end
+
   # Attempts to set an instance of the DSC resource, invoking the `Set` method and thinly wrapping
   # the `invoke_set_method` method; whether this method, `update`, or `delete` is called is entirely
   # up to the Resource API based on the results
@@ -158,9 +229,7 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     context.debug("retrieving #{name_hash.inspect}")
 
     # Do not bother running if the logon credentials won't work
-    unless name_hash[:dsc_psdscrunascredential].nil?
-      return name_hash if logon_failed_already?(name_hash[:dsc_psdscrunascredential])
-    end
+    return name_hash if !name_hash[:dsc_psdscrunascredential].nil? && logon_failed_already?(name_hash[:dsc_psdscrunascredential])
 
     query_props = name_hash.select { |k, v| mandatory_get_attributes(context).include?(k) || (k == :dsc_psdscrunascredential && !v.nil?) }
     resource = should_to_resource(query_props, context, 'get')
@@ -190,28 +259,27 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     # DSC gives back information we don't care about; filter down to only
     # those properties exposed in the type definition.
     valid_attributes = context.type.attributes.keys.collect(&:to_s)
+    parameters = context.type.attributes.select { |_name, properties| [properties[:behaviour]].collect.include?(:parameter) }.keys.collect(&:to_s)
     data.select! { |key, _value| valid_attributes.include?("dsc_#{key.downcase}") }
+    data.reject! { |key, _value| parameters.include?("dsc_#{key.downcase}") }
     # Canonicalize the results to match the type definition representation;
     # failure to do so will prevent the resource_api from comparing the result
     # to the should hash retrieved from the resource definition in the manifest.
-    data.keys.each do |key|
+    data.keys.each do |key| # rubocop:disable Style/HashEachMethods
       type_key = "dsc_#{key.downcase}".to_sym
       data[type_key] = data.delete(key)
       camelcase_hash_keys!(data[type_key]) if data[type_key].is_a?(Enumerable)
+      # Convert DateTime back to appropriate type
+      data[type_key] = Puppet::Pops::Time::Timestamp.parse(data[type_key]) if context.type.attributes[type_key][:mof_type] =~ /DateTime/i
+      # PowerShell does not distinguish between a return of empty array/string
+      #  and null but Puppet does; revert to those values if specified.
+      if data[type_key].nil? && query_props.keys.include?(type_key) && query_props[type_key].is_a?(Array)
+        data[type_key] = query_props[type_key].empty? ? query_props[type_key] : []
+      end
     end
-    # If a resource is found, it's present, so refill these two Puppet-only keys
+    # If a resource is found, it's present, so refill this Puppet-only key
     data.merge!({ name: name_hash[:name] })
-    if ensurable?(context)
-      ensure_value = data.key?(:dsc_ensure) ? data[:dsc_ensure].downcase : 'present'
-      data.merge!({ ensure: ensure_value })
-    end
-    # TODO: Handle PSDscRunAsCredential flapping
-    # Resources do not return the account under which they were discovered, so re-add that
-    if name_hash[:dsc_psdscrunascredential].nil?
-      data.delete(:dsc_psdscrunascredential)
-    else
-      data.merge!({ dsc_psdscrunascredential: name_hash[:dsc_psdscrunascredential] })
-    end
+
     # Cache the query to prevent a second lookup
     @@cached_query_results << data.dup if fetch_cached_hashes(@@cached_query_results, [data]).empty?
     context.debug("Returned to Puppet as #{data}")
@@ -229,9 +297,7 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     context.debug("Invoking Set Method for '#{name}' with #{should.inspect}")
 
     # Do not bother running if the logon credentials won't work
-    unless should[:dsc_psdscrunascredential].nil?
-      return nil if logon_failed_already?(should[:dsc_psdscrunascredential])
-    end
+    return nil if !should[:dsc_psdscrunascredential].nil? && logon_failed_already?(should[:dsc_psdscrunascredential])
 
     apply_props = should.select { |k, _v| k.to_s =~ /^dsc_/ }
     resource = should_to_resource(apply_props, context, 'set')
@@ -265,7 +331,6 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
       resource[k] = context.type.definition[k]
     end
     should.each do |k, v|
-      next if k == :ensure
       # PSDscRunAsCredential is considered a namevar and will always be passed, even if nil
       # To prevent flapping during runs, remove it from the resource definition unless specified
       next if k == :dsc_psdscrunascredential && v.nil?
@@ -283,9 +348,9 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     # During a Puppet agent run, the code lives in the cache so we can use the file expansion to discover the correct folder.
     root_module_path = $LOAD_PATH.select { |path| path.match?(%r{#{resource[:dscmeta_module_name].downcase}/lib}) }.first
     resource[:vendored_modules_path] = if root_module_path.nil?
-                                         File.expand_path(Pathname.new(__FILE__).dirname + '../../../' + 'puppet_x/dsc_resources')
+                                         File.expand_path(Pathname.new(__FILE__).dirname + '../../../' + 'puppet_x/dsc_resources') # rubocop:disable Style/StringConcatenation
                                        else
-                                         File.expand_path(root_module_path + '/puppet_x/dsc_resources')
+                                         File.expand_path("#{root_module_path}/puppet_x/dsc_resources")
                                        end
     resource[:attributes] = nil
     context.debug("should_to_resource: #{resource.inspect}")
@@ -331,7 +396,7 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
   # @return [Enumerable] returns the input object with hash keys recursively camelCased
   def camelcase_hash_keys!(enumerable)
     if enumerable.is_a?(Hash)
-      enumerable.keys.each do |key|
+      enumerable.keys.each do |key| # rubocop:disable Style/HashEachMethods
         name = key.dup
         name[0] = name[0].downcase
         enumerable[name] = enumerable.delete(key)
@@ -363,14 +428,6 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     end
   end
 
-  # Checks to see whether the DSC resource being managed is defined as ensurable
-  #
-  # @param context [Object] the Puppet runtime context to operate in and send feedback to
-  # @return [Bool] returns true if the DSC Resource is ensurable, otherwise false.
-  def ensurable?(context)
-    context.type.attributes.keys.include?(:ensure)
-  end
-
   # Parses the DSC resource type definition to retrieve the names of any attributes which are specified as mandatory for get operations
   #
   # @param context [Object] the Puppet runtime context to operate in and send feedback to
@@ -441,8 +498,7 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
   # @param credential_hash [Hash] the Properties which define the PSCredential Object
   # @return [String] A line of PowerShell which defines the PSCredential object and stores it to a variable
   def format_pscredential(variable_name, credential_hash)
-    definition = "$#{variable_name} = New-PSCredential -User #{credential_hash['user']} -Password '#{credential_hash['password']}' # PuppetSensitive"
-    definition
+    "$#{variable_name} = New-PSCredential -User #{credential_hash['user']} -Password '#{credential_hash['password']}' # PuppetSensitive"
   end
 
   # Parses a resource definition (as from `should_to_resource`) for any properties which are CIM instances
@@ -522,8 +578,7 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     # EVEN WORSE HACK - this one we can't even be sure it's a cim instance...
     # but I don't _think_ anything but nested cim instances show up as hashes inside an array
     definition = definition.gsub('@(@{', '[CimInstance[]]@(@{')
-    definition = interpolate_variables(definition)
-    definition
+    interpolate_variables(definition)
   end
 
   # Munge a resource definition (as from `should_to_resource`) into valid PowerShell which represents
@@ -548,18 +603,32 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     resource[:parameters].each do |property_name, property_hash|
       # strip dsc_ from the beginning of the property name declaration
       name = property_name.to_s.gsub(/^dsc_/, '').to_sym
-      params[:Property][name] = if property_hash[:mof_type] == 'PSCredential'
+      params[:Property][name] = case property_hash[:mof_type]
+                                when 'PSCredential'
                                   # format can't unwrap Sensitive strings nested in arbitrary hashes/etc, so make
                                   # the Credential hash interpolable as it will be replaced by a variable reference.
                                   {
                                     'user' => property_hash[:value]['user'],
                                     'password' => escape_quotes(property_hash[:value]['password'].unwrap)
                                   }
+                                when 'DateTime'
+                                  # These have to be handled specifically because they rely on the *Puppet* DateTime,
+                                  # not a generic ruby data type (and so can't go in the shared util in ruby-pwsh)
+                                  "[DateTime]#{property_hash[:value].format('%FT%T%z')}"
                                 else
                                   property_hash[:value]
                                 end
     end
     params_block = interpolate_variables("$InvokeParams = #{format(params)}")
+    # Move the Apostrophe for DateTime declarations
+    params_block = params_block.gsub("'[DateTime]", "[DateTime]'")
+    # HACK: Handle intentionally empty arrays - need to strongly type them because
+    # CIM instances do not do a consistent job of casting an empty array properly.
+    empty_array_parameters = resource[:parameters].select { |_k, v| v[:value].empty? }
+    empty_array_parameters.each do |name, properties|
+      param_block_name = name.to_s.gsub(/^dsc_/, '')
+      params_block = params_block.gsub("#{param_block_name} = @()", "#{param_block_name} = [#{properties[:mof_type]}]@()")
+    end
     # HACK: make CIM instances work:
     resource[:parameters].select { |_key, hash| hash[:mof_is_embedded] && hash[:mof_type] =~ /\[\]/ }.each do |_property_name, property_hash|
       formatted_property_hash = interpolate_variables(format(property_hash[:value]))
@@ -577,11 +646,11 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
   def ps_script_content(resource)
     template_path = File.expand_path('../', __FILE__)
     # Defines the helper functions
-    functions     = File.new(template_path + '/invoke_dsc_resource_functions.ps1').read
+    functions     = File.new("#{template_path}/invoke_dsc_resource_functions.ps1").read
     # Defines the response hash and the runtime settings
-    preamble      = File.new(template_path + '/invoke_dsc_resource_preamble.ps1').read
+    preamble      = File.new("#{template_path}/invoke_dsc_resource_preamble.ps1").read
     # The postscript defines the invocation error and result handling; expects `$InvokeParams` to be defined
-    postscript    = File.new(template_path + '/invoke_dsc_resource_postscript.ps1').read
+    postscript    = File.new("#{template_path}/invoke_dsc_resource_postscript.ps1").read
     # The blocks define the variables to define for the postscript.
     credential_block = prepare_credentials(resource)
     cim_instances_block = prepare_cim_instances(resource)
@@ -589,8 +658,7 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
     # clean them out of the temporary cache now that they're not needed; failure to do so can goof up future executions in this run
     clear_instantiated_variables!
 
-    content = [functions, preamble, credential_block, cim_instances_block, parameters_block, postscript].join("\n")
-    content
+    [functions, preamble, credential_block, cim_instances_block, parameters_block, postscript].join("\n")
   end
 
   # Convert a Puppet/Ruby value into a PowerShell representation. Requires some slight additional
@@ -614,15 +682,16 @@ class Puppet::Provider::DscBaseProvider < Puppet::ResourceApi::SimpleProvider
   # @param value [Object] The object to unwrap sensitive data inside of
   # @return [Object] The object with any sensitive strings unwrapped and annotated
   def unwrap(value)
-    if value.class.name == 'Puppet::Pops::Types::PSensitiveType::Sensitive'
+    case value
+    when Puppet::Pops::Types::PSensitiveType::Sensitive
       "#{value.unwrap}#PuppetSensitive"
-    elsif value.class.name == 'Hash'
+    when Hash
       unwrapped = {}
       value.each do |k, v|
         unwrapped[k] = unwrap(v)
       end
       unwrapped
-    elsif value.class.name == 'Array'
+    when Array
       unwrapped = []
       value.each do |v|
         unwrapped << unwrap(v)

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

@@ -68,6 +68,10 @@ Function ConvertTo-CanonicalResult {
               $Value = $null
           }
       }
+      elseif ($Result.$PropertyName.GetType().Name -match 'DateTime') {
+          # Handle DateTimes especially since they're an edge case
+          $Value = Get-Date $Result.$PropertyName -UFormat "%Y-%m-%dT%H:%M:%S%Z"
+      }
       else {
           # Looks like a nested CIM instance, recurse if we're not too deep in already.
           $RecursionLevel++

data/lib/pwsh.rb

@@ -14,10 +14,10 @@ require 'logger'
 module Pwsh
   # Standard errors
   class Error < StandardError; end
+
   # Create an instance of a PowerShell host and manage execution of PowerShell code inside that host.
   class Manager
-    attr_reader :powershell_command
-    attr_reader :powershell_arguments
+    attr_reader :powershell_command, :powershell_arguments
 
     # We actually want this to be a class variable.
     @@instances = {} # rubocop:disable Style/ClassVars
@@ -70,7 +70,7 @@ module Pwsh
     def self.win32console_enabled?
       @win32console_enabled ||= defined?(Win32) &&
                                 defined?(Win32::Console) &&
-                                Win32::Console.class == Class
+                                Win32::Console.instance_of?(Class)
     end
 
     # TODO: This thing isn't called anywhere and the variable it sets is never referenced...

data/lib/pwsh/util.rb

@@ -117,16 +117,16 @@ module Pwsh
     #
     # @return [String] representation of the value for interpolation
     def format_powershell_value(object)
-      if %i[true false].include?(object) || %w[trueclass falseclass].include?(object.class.name.downcase) # rubocop:disable Lint/BooleanSymbol
+      if %i[true false].include?(object) || %w[trueclass falseclass].include?(object.class.name.downcase)
         "$#{object}"
-      elsif object.class.name == 'Symbol' || object.class.ancestors.include?(Numeric)
+      elsif object.instance_of?(Symbol) || object.class.ancestors.include?(Numeric)
         object.to_s
-      elsif object.class.name == 'String'
+      elsif object.instance_of?(String)
         "'#{escape_quotes(object)}'"
-      elsif object.class.name == 'Array'
-        '@(' + object.collect { |item| format_powershell_value(item) }.join(', ') + ')'
-      elsif object.class.name == 'Hash'
-        '@{' + object.collect { |k, v| format_powershell_value(k) + ' = ' + format_powershell_value(v) }.join('; ') + '}'
+      elsif object.instance_of?(Array)
+        "@(#{object.collect { |item| format_powershell_value(item) }.join(', ')})"
+      elsif object.instance_of?(Hash)
+        "@{#{object.collect { |k, v| "#{format_powershell_value(k)} = #{format_powershell_value(v)}" }.join('; ')}}"
       else
         raise "unsupported type #{object.class} of value '#{object}'"
       end

data/lib/pwsh/version.rb

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

data/metadata.json

@@ -1,6 +1,6 @@
 {
   "name": "puppetlabs-pwshlib",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "author": "puppetlabs",
   "summary": "Provide library code for interoperating with PowerShell.",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-pwsh
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-25 00:00:00.000000000 Z
+date: 2020-11-24 00:00:00.000000000 Z
 dependencies: []
 description: PowerShell code manager for ruby.
 email: