chef 16.5.64-universal-mingw32 → 16.8.14-universal-mingw32

data/lib/chef/resource/windows_workgroup.rb

@@ -21,6 +21,8 @@ require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 class Chef
   class Resource
     class WindowsWorkgroup < Chef::Resource
+      unified_mode true
+
       provides :windows_workgroup
 
       description "Use the **windows_workgroup** resource to join or change the workgroup of a Windows host."
@@ -90,8 +92,8 @@ class Chef
 
         unless workgroup_member?
           converge_by("join workstation workgroup #{new_resource.workgroup_name}") do
-            ps_run = powershell_out(join_command)
-            raise "Failed to join the workgroup #{new_resource.workgroup_name}: #{ps_run.stderr}}" if ps_run.error?
+            ps_run = powershell_exec(join_command)
+            raise "Failed to join the workgroup #{new_resource.workgroup_name}: #{ps_run.errors}}" if ps_run.error?
 
             unless new_resource.reboot == :never
               reboot "Reboot to join workgroup #{new_resource.workgroup_name}" do
@@ -117,10 +119,10 @@ class Chef
 
         # @return [Boolean] is the node a member of the workgroup specified in the resource
         def workgroup_member?
-          node_workgroup = powershell_out!("(Get-WmiObject -Class Win32_ComputerSystem).Workgroup")
+          node_workgroup = powershell_exec!("(Get-WmiObject -Class Win32_ComputerSystem).Workgroup")
           raise "Failed to determine if system already a member of workgroup #{new_resource.workgroup_name}" if node_workgroup.error?
 
-          node_workgroup.stdout.downcase.strip == new_resource.workgroup_name.downcase
+          String(node_workgroup.result).downcase.strip == new_resource.workgroup_name.downcase
         end
       end
     end

data/lib/chef/resource/yum_repository.rb

@@ -37,7 +37,7 @@ class Chef
         gpgkey 'http://artifacts.ourco.org/pub/yum/RPM-GPG-KEY-OURCO-8'
         action :create
       end
-      ```ruby
+      ```
 
       **Delete a repository**:
 

data/lib/chef/resource_collection/resource_set.rb

@@ -123,11 +123,7 @@ class Chef
       # * Chef::Exceptions::InvalidResourceSpecification for all invalid input.
       def validate_lookup_spec!(query_object)
         case query_object
-          when Chef::Resource
-            true
-          when SINGLE_RESOURCE_MATCH, MULTIPLE_RESOURCE_MATCH, NAMELESS_RESOURCE_MATCH
-            true
-          when Hash
+          when Chef::Resource, SINGLE_RESOURCE_MATCH, MULTIPLE_RESOURCE_MATCH, NAMELESS_RESOURCE_MATCH, Hash
             true
           when String
             raise Chef::Exceptions::InvalidResourceSpecification,
@@ -135,7 +131,7 @@ class Chef
           else
             raise Chef::Exceptions::InvalidResourceSpecification,
               "The object `#{query_object.inspect}' is not valid for resource collection lookup. " +
-              "Use a String like `resource_type[resource_name]' or a Chef::Resource object"
+                "Use a String like `resource_type[resource_name]' or a Chef::Resource object"
         end
       end
 

data/lib/chef/resource_inspector.rb

@@ -23,94 +23,96 @@ require_relative "node"
 require_relative "resources"
 require_relative "json_compat"
 
-module ResourceInspector
-  def self.get_default(default)
-    if default.is_a?(Chef::DelayedEvaluator)
-      # ideally we'd get the block we pass to `lazy`, but the best we can do
-      # is to get the source location, which then results in reparsing the source
-      # code for the resource ourselves and just no
-      "lazy default"
-    else
-      default.is_a?(Symbol) ? default.inspect : default # inspect properly returns symbols
+class Chef
+  module ResourceInspector
+    def self.get_default(default)
+      if default.is_a?(Chef::DelayedEvaluator)
+        # ideally we'd get the block we pass to `lazy`, but the best we can do
+        # is to get the source location, which then results in reparsing the source
+        # code for the resource ourselves and just no
+        "lazy default"
+      else
+        default.is_a?(Symbol) ? default.inspect : default # inspect properly returns symbols
+      end
     end
-  end
 
-  def self.extract_resource(resource, complete = false)
-    data = {}
-    data[:description] = resource.description
-    # data[:deprecated] = resource.deprecated || false
-    data[:default_action] = resource.default_action
-    data[:actions] = resource.allowed_actions
-    data[:examples] = resource.examples
-    data[:introduced] = resource.introduced
-    data[:preview] = resource.preview_resource
+    def self.extract_resource(resource, complete = false)
+      data = {}
+      data[:description] = resource.description
+      # data[:deprecated] = resource.deprecated || false
+      data[:default_action] = resource.default_action
+      data[:actions] = resource.allowed_actions
+      data[:examples] = resource.examples
+      data[:introduced] = resource.introduced
+      data[:preview] = resource.preview_resource
 
-    properties = unless complete
-                   resource.properties.reject { |_, k| k.options[:declared_in] == Chef::Resource || k.options[:skip_docs] }
-                 else
-                   resource.properties.reject { |_, k| k.options[:skip_docs] }
-                 end
+      properties = unless complete
+                     resource.properties.reject { |_, k| k.options[:declared_in] == Chef::Resource || k.options[:skip_docs] }
+                   else
+                     resource.properties.reject { |_, k| k.options[:skip_docs] }
+                   end
 
-    data[:properties] = properties.each_with_object([]) do |(n, k), acc|
-      opts = k.options
-      acc << { name: n, description: opts[:description],
-               introduced: opts[:introduced], is: opts[:is],
-               deprecated: opts[:deprecated] || false,
-               required: opts[:required] || false,
-               default: opts[:default_description] || get_default(opts[:default]),
-               name_property: opts[:name_property] || false,
-               equal_to: sort_equal_to(opts[:equal_to]) }
+      data[:properties] = properties.each_with_object([]) do |(n, k), acc|
+        opts = k.options
+        acc << { name: n, description: opts[:description],
+                 introduced: opts[:introduced], is: opts[:is],
+                 deprecated: opts[:deprecated] || false,
+                 required: opts[:required] || false,
+                 default: opts[:default_description] || get_default(opts[:default]),
+                 name_property: opts[:name_property] || false,
+                 equal_to: sort_equal_to(opts[:equal_to]) }
+      end
+      data
     end
-    data
-  end
 
-  def self.sort_equal_to(equal_to)
-    Array(equal_to).sort.map(&:inspect)
-  rescue ArgumentError
-    Array(equal_to).map(&:inspect)
-  end
+    def self.sort_equal_to(equal_to)
+      Array(equal_to).sort.map(&:inspect)
+    rescue ArgumentError
+      Array(equal_to).map(&:inspect)
+    end
 
-  def self.extract_cookbook(path, complete)
-    path = File.expand_path(path)
-    dir, name = File.split(path)
-    Chef::Cookbook::FileVendor.fetch_from_disk(path)
-    loader = Chef::CookbookLoader.new(dir)
-    cookbook = loader.load_cookbook(name)
-    resources = cookbook.files_for(:resources)
+    def self.extract_cookbook(path, complete)
+      path = File.expand_path(path)
+      dir, name = File.split(path)
+      Chef::Cookbook::FileVendor.fetch_from_disk(path)
+      loader = Chef::CookbookLoader.new(dir)
+      cookbook = loader.load_cookbook(name)
+      resources = cookbook.files_for(:resources)
 
-    resources.each_with_object({}) do |r, res|
-      pth = r["full_path"]
-      cur = Chef::Resource::LWRPBase.build_from_file(name, pth, Chef::RunContext.new(Chef::Node.new, nil, nil))
-      res[cur.resource_name] = extract_resource(cur, complete)
+      resources.each_with_object({}) do |r, res|
+        pth = r["full_path"]
+        cur = Chef::Resource::LWRPBase.build_from_file(name, pth, Chef::RunContext.new(Chef::Node.new, nil, nil))
+        res[cur.resource_name] = extract_resource(cur, complete)
+      end
     end
-  end
 
-  # If we're given no resources, dump all of Chef's built ins
-  # otherwise, if we have a path then extract all the resources from the cookbook
-  # or else do a list of built in resources
-  #
-  # @param arguments [Array, String] One of more paths to a cookbook or a resource file to inspect
-  # @param complete [TrueClass, FalseClass] Whether to show properties defined in the base Resource class
-  # @return [String] JSON formatting of all resources
-  def self.inspect(arguments = [], complete: false)
-    output = if arguments.empty?
-               ObjectSpace.each_object(Class).select { |k| k < Chef::Resource }.each_with_object({}) { |klass, acc| acc[klass.resource_name] = extract_resource(klass) }
-             else
-               Array(arguments).each_with_object({}) do |arg, acc|
-                 if File.directory?(arg)
-                   extract_cookbook(arg, complete).each { |k, v| acc[k] = v }
-                 else
-                   r = Chef::ResourceResolver.resolve(arg.to_sym)
-                   acc[r.resource_name] = extract_resource(r, complete)
+    # If we're given no resources, dump all of Chef's built ins
+    # otherwise, if we have a path then extract all the resources from the cookbook
+    # or else do a list of built in resources
+    #
+    # @param arguments [Array, String] One of more paths to a cookbook or a resource file to inspect
+    # @param complete [TrueClass, FalseClass] Whether to show properties defined in the base Resource class
+    # @return [String] JSON formatting of all resources
+    def self.inspect(arguments = [], complete: false)
+      output = if arguments.empty?
+                 ObjectSpace.each_object(Class).select { |k| k < Chef::Resource }.each_with_object({}) { |klass, acc| acc[klass.resource_name] = extract_resource(klass) }
+               else
+                 Array(arguments).each_with_object({}) do |arg, acc|
+                   if File.directory?(arg)
+                     extract_cookbook(arg, complete).each { |k, v| acc[k] = v }
+                   else
+                     r = Chef::ResourceResolver.resolve(arg.to_sym)
+                     acc[r.resource_name] = extract_resource(r, complete)
+                   end
                  end
                end
-             end
 
-    Chef::JSONCompat.to_json_pretty(output)
-  end
+      Chef::JSONCompat.to_json_pretty(output)
+    end
 
-  def self.start
-    puts inspect(ARGV, complete: true)
-  end
+    def self.start
+      puts inspect(ARGV, complete: true)
+    end
 
+  end
 end

data/lib/chef/resource_reporter.rb

@@ -19,8 +19,6 @@
 # limitations under the License.
 #
 
-require "uri" unless defined?(URI)
-require "securerandom" unless defined?(SecureRandom)
 require_relative "event_dispatch/base"
 
 class Chef

data/lib/chef/resources.rb

@@ -27,6 +27,7 @@ require_relative "resource/batch"
 require_relative "resource/breakpoint"
 require_relative "resource/build_essential"
 require_relative "resource/cookbook_file"
+require_relative "resource/chef_client_config"
 require_relative "resource/chef_client_cron"
 require_relative "resource/chef_client_launchd"
 require_relative "resource/chef_client_scheduled_task"

data/lib/chef/run_lock.rb

@@ -23,7 +23,7 @@ end
 require_relative "config"
 require_relative "exceptions"
 require "timeout" unless defined?(Timeout)
-require "chef-utils" unless defined?(ChefUtils)
+require "chef-utils" unless defined?(ChefUtils::CANARY)
 
 class Chef
 
@@ -173,7 +173,7 @@ class Chef
     # Mutex name is case-sensitive contrary to other things in
     # windows. "\" is the only invalid character.
     def acquire_win32_mutex
-      @mutex = Chef::ReservedNames::Win32::Mutex.new("Global\\#{runlock_file.gsub(/[\\]/, "/").downcase}")
+      @mutex = Chef::ReservedNames::Win32::Mutex.new("Global\\#{runlock_file.tr('\\', "/").downcase}")
       mutex.test
     end
 

data/lib/chef/search/query.rb

@@ -21,7 +21,9 @@ require_relative "../exceptions"
 require_relative "../server_api"
 
 autoload :URI, "uri"
-autoload :Addressable, "addressable/uri"
+module Addressable
+  autoload :URI, "addressable/uri"
+end
 
 class Chef
   class Search

data/lib/chef/server_api.rb

@@ -71,10 +71,6 @@ class Chef
       return_value
     rescue Exception => exception
       log_failed_request(response, return_value) unless response.nil?
-
-      if exception.respond_to?(:chef_rest_request=)
-        exception.chef_rest_request = rest_request
-      end
       raise
     end
   end

data/lib/chef/shell/ext.rb

@@ -62,7 +62,7 @@ module Shell
         if subsession = jobs.select_shell_session(context_obj)
           jobs.switch(subsession)
         else
-          irb(context_obj)
+          irb(context_obj) # rubocop: disable Lint/Debugger
         end
       end
 

data/lib/chef/util/backup.rb

@@ -36,7 +36,7 @@ class Chef
           slice_number = @new_resource.backup
           backup_files = sorted_backup_files
           if backup_files.length >= @new_resource.backup
-            remainder = backup_files.slice(slice_number..-1)
+            remainder = backup_files.slice(slice_number..)
             remainder.each do |backup_to_delete|
               delete_backup(backup_to_delete)
             end

data/lib/chef/util/dsc/configuration_generator.rb

@@ -16,36 +16,34 @@
 # limitations under the License.
 #
 
-require_relative "../powershell/cmdlet"
+require_relative "../../mixin/powershell_exec"
 
 class Chef::Util::DSC
   class ConfigurationGenerator
+    include Chef::Mixin::PowershellExec
+
     def initialize(node, config_directory)
       @node = node
       @config_directory = config_directory
     end
 
-    def configuration_document_from_script_code(code, configuration_flags, imports, shellout_flags)
+    def configuration_document_from_script_code(code, configuration_flags, imports)
       Chef::Log.trace("DSC: DSC code:\n '#{code}'")
       generated_script_path = write_document_generation_script(code, "chef_dsc", imports)
       begin
-        configuration_document_from_script_path(generated_script_path, "chef_dsc", configuration_flags, shellout_flags)
+        configuration_document_from_script_path(generated_script_path, "chef_dsc", configuration_flags)
       ensure
         ::FileUtils.rm(generated_script_path)
       end
     end
 
-    def configuration_document_from_script_path(script_path, configuration_name, configuration_flags, shellout_flags)
+    def configuration_document_from_script_path(script_path, configuration_name, configuration_flags)
       validate_configuration_name!(configuration_name)
 
-      document_generation_cmdlet = Chef::Util::Powershell::Cmdlet.new(
-        @node,
-        configuration_document_generation_code(script_path, configuration_name)
-      )
-
-      merged_configuration_flags = get_merged_configuration_flags!(configuration_flags, configuration_name)
+      config_generation_code = configuration_document_generation_code(script_path, configuration_name)
+      switches_string = command_switches_string(get_merged_configuration_flags!(configuration_flags, configuration_name))
 
-      document_generation_cmdlet.run!(merged_configuration_flags, shellout_flags)
+      powershell_exec!("#{config_generation_code} #{switches_string}")
       configuration_document_location = find_configuration_document(configuration_name)
 
       unless configuration_document_location
@@ -59,6 +57,49 @@ class Chef::Util::DSC
 
     protected
 
+    def validate_switch_name!(switch_parameter_name)
+      unless switch_parameter_name.match?(/\A[A-Za-z]+[_a-zA-Z0-9]*\Z/)
+        raise ArgumentError, "`#{switch_parameter_name}` is not a valid PowerShell cmdlet switch parameter name"
+      end
+    end
+
+    def escape_parameter_value(parameter_value)
+      parameter_value.gsub(/(`|'|"|#)/, '`\1')
+    end
+
+    def escape_string_parameter_value(parameter_value)
+      "'#{escape_parameter_value(parameter_value)}'"
+    end
+
+    def command_switches_string(switches)
+      command_switches = switches.map do |switch_name, switch_value|
+        if switch_name.class != Symbol
+          raise ArgumentError, "Invalid type `#{switch_name} `for PowerShell switch '#{switch_name}'. The switch must be specified as a Symbol'"
+        end
+
+        validate_switch_name!(switch_name)
+
+        switch_argument = ""
+        switch_present = true
+
+        case switch_value
+        when Numeric, Float
+          switch_argument = switch_value.to_s
+        when FalseClass
+          switch_present = false
+        when TrueClass
+        when String
+          switch_argument = escape_string_parameter_value(switch_value)
+        else
+          raise ArgumentError, "Invalid argument type `#{switch_value.class}` specified for PowerShell switch `:#{switch_name}`. Arguments to PowerShell must be of type `String`, `Numeric`, `Float`, `FalseClass`, or `TrueClass`"
+        end
+
+        switch_present ? ["-#{switch_name.to_s.downcase}", switch_argument].join(" ").strip : ""
+      end
+
+      command_switches.join(" ")
+    end
+
     # From PowerShell error help for the Configuration language element:
     #   Standard names may only contain letters (a-z, A-Z), numbers (0-9), and underscore (_).
     #   The name may not be null or empty, and should start with a letter.

data/lib/chef/util/dsc/lcm_output_parser.rb

@@ -75,23 +75,21 @@ class Chef
           #
 
           def self.parse(lcm_output, test_dsc_configuration)
+            lcm_output = String(lcm_output).split("\n")
             test_dsc_configuration ? test_dsc_parser(lcm_output) : what_if_parser(lcm_output)
           end
 
           def self.test_dsc_parser(lcm_output)
-            lcm_output ||= ""
             current_resource = {}
 
             resources = []
-            lcm_output.lines.each do |line|
+            lcm_output.each do |line|
               op_action , op_value = line.strip.split(":")
               op_action&.strip!
               case op_action
               when "InDesiredState"
                 current_resource[:skipped] = op_value.strip == "True" ? true : false
-              when "ResourcesInDesiredState"
-                current_resource[:name] = op_value.strip if op_value
-              when "ResourcesNotInDesiredState"
+              when "ResourcesInDesiredState", "ResourcesNotInDesiredState"
                 current_resource[:name] = op_value.strip if op_value
               when "ReturnValue"
                 current_resource[:context] = nil
@@ -109,11 +107,10 @@ class Chef
           end
 
           def self.what_if_parser(lcm_output)
-            lcm_output ||= ""
             current_resource = {}
 
             resources = []
-            lcm_output.lines.each do |line|
+            lcm_output.each do |line|
               op_action, op_type, info = parse_line(line)
 
               case op_action