chef 12.21.14-universal-mingw32 → 12.21.20-universal-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa8afdf8ff2a200af3c6c0ee7204158d0a80e631
-  data.tar.gz: 07ef2ec6d60ca183435a4601b4eebe19186cc869
+  metadata.gz: 5503ffce112604e7fb025b86f087c3b82a8b0de0
+  data.tar.gz: a57cb1c814dc50488defc108568b74cc99c42e36
 SHA512:
-  metadata.gz: 0a1d169eb5a77d775c8b169893bdd2955e3091a90639356ab45223f0061c19f72adf767e202c42d444f0a931f4723b5ad3f351315f70973bd325c387440035a1
-  data.tar.gz: '0296ed11facff4c78e4d88abaee1e74693bf3e6ecaca40e694c34bd0730813fa7f1beb90a6e17d1ad3a4879e33217e14d763e02a232a4f4e78d47b7bb25371fe'
+  metadata.gz: 02f09b4afe63ce8541d90445a7960f5b04fd9bb84b323453a00cb5fc7e7fee186cd81e87e0ce5aa3c49c86e3e154243fd5662f049af606d9282efbb335cd7c11
+  data.tar.gz: 9b6b1602dc122533f216fb5863eed4065fa243c8645f31fec0728538ac2b1561ff6d617ff8f9c6a1c231d8422c27531b40fab78be76464ddbb5ddcc5d4c11fca

data/README.md

@@ -291,7 +291,7 @@ Chef - A configuration management system
 |                      |                                          |
 |:---------------------|:-----------------------------------------|
 | **Author:**          | Adam Jacob (<adam@chef.io>)
-| **Copyright:**       | Copyright 2008-2016, Chef Software, Inc.
+| **Copyright:**       | Copyright 2008-2017, Chef Software, Inc.
 | **License:**         | Apache License, Version 2.0
 
 ```

data/Rakefile

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/VERSION

@@ -1 +1 @@
-12.21.14
+12.21.20

data/lib/chef/client.rb

@@ -605,6 +605,9 @@ class Chef
       filter = Chef::Config[:minimal_ohai] ? %w{fqdn machinename hostname platform platform_version os os_version} : nil
       ohai.all_plugins(filter)
       events.ohai_completed(node)
+    rescue Ohai::Exceptions::CriticalPluginFailure => e
+      Chef::Log.error("Critical Ohai plugins failed: #{e.message}")
+      exit(false)
     end
 
     #

data/lib/chef/provider/dsc_script.rb

@@ -165,7 +165,11 @@ class Chef
             if resource.changes_state?
               # We ignore the last log message because it only contains the time it took, which looks weird
               cleaned_messages = resource.change_log[0..-2].map { |c| c.sub(/^#{Regexp.escape(resource.name)}/, "").strip }
-              "converge DSC resource #{resource.name} by #{cleaned_messages.find_all { |c| c != '' }.join("\n")}"
+              unless cleaned_messages.empty?
+                "converge DSC resource #{resource.name} by #{cleaned_messages.find_all { |c| c != '' }.join("\n")}"
+              else
+                "converge DSC resource #{resource.name}"
+              end
             else
               # This is needed because a dsc script can have resources that are both converged and not
               "converge DSC resource #{resource.name} by doing nothing because it is already converged"

data/lib/chef/provider/package/dnf.rb

@@ -35,13 +35,18 @@ class Chef
         use_multipackage_api
         use_package_name_for_source
 
-        provides :package, platform_family: %w{fedora} do
-          which("dnf") && shell_out("rpm -q dnf").stdout =~ /^dnf-[1-9]/
-        end
+        # all rhel variants >= 8 will use DNF
+        provides :package, platform_family: "rhel", platform: "!amazon", platform_version: ">= 8"
+
+        # fedora >= 22 uses DNF
+        provides :package, platform: "fedora", platform_version: ">= 22"
 
-        provides :package, platform_family: %w{rhel}, platform_version: ">= 8"
+        # amazon will eventually use DNF
+        provides :package, platform: "amazon" do
+          which("dnf")
+        end
 
-        provides :dnf_package, os: "linux"
+        provides :dnf_package
 
         #
         # Most of the magic in this class happens in the python helper script.  The ruby side of this

data/lib/chef/resource/dnf_package.rb

@@ -29,8 +29,15 @@ class Chef
 
       allowed_actions :install, :upgrade, :remove, :purge, :reconfig, :lock, :unlock, :flush_cache
 
-      provides :package, platform_family: %w{rhel fedora} do
-        which("dnf") && shell_out("rpm -q dnf").stdout =~ /^dnf-[1-9]/
+      # all rhel variants >= 8 will use DNF
+      provides :package, platform_family: "rhel", platform: "!amazon", platform_version: ">= 8"
+
+      # fedora >= 22 uses DNF
+      provides :package, platform: "fedora", platform_version: ">= 22"
+
+      # amazon will eventually use DNF
+      provides :package, platform: "amazon" do
+        which("dnf")
       end
 
       provides :dnf_package

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

@@ -28,7 +28,7 @@ class Chef
           # Parses the output from LCM and returns a list of Chef::Util::DSC::ResourceInfo objects
           # that describe how the resources affected the system
           #
-          # Example:
+          # Example for WhatIfParser:
           #   parse <<-EOF
           #   What if: [Machine]: LCM: [Start Set      ]
           #   What if: [Machine]: LCM: [Start Resource ] [[File]FileToNotBeThere]
@@ -53,7 +53,62 @@ class Chef
           #     )
           #   ]
           #
-          def self.parse(lcm_output)
+          # Example for TestDSCParser:
+          #   parse <<-EOF
+          #   InDesiredState            : False
+          #   ResourcesInDesiredState   :
+          #   ResourcesNotInDesiredState: {[Environment]texteditor}
+          #   ReturnValue               : 0
+          #   PSComputerName            : .
+          #   EOF
+          #
+          #   would return
+          #
+          #   [
+          #     Chef::Util::DSC::ResourceInfo.new(
+          #       '{[Environment]texteditor}',
+          #       true,
+          #       [
+          #       ]
+          #     )
+          #   ]
+          #
+
+          def self.parse(lcm_output, test_dsc_configuration)
+            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 = Hash.new
+
+            resources = []
+            lcm_output.lines.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"
+                current_resource[:name] = op_value.strip if op_value
+              when "ReturnValue"
+                current_resource[:context] = nil
+              end
+            end
+            if current_resource[:name]
+              resources.push(current_resource)
+            end
+
+            if resources.length > 0
+              build_resource_info(resources)
+            else
+              raise Chef::Exceptions::LCMParser, "Could not parse:\n#{lcm_output}"
+            end
+          end
+
+          def self.what_if_parser(lcm_output)
             lcm_output ||= ""
             current_resource = Hash.new
 

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

@@ -29,7 +29,7 @@ class Chef::Util::DSC
 
     def test_configuration(configuration_document, shellout_flags)
       status = run_configuration_cmdlet(configuration_document, false, shellout_flags)
-      log_what_if_exception(status.stderr) unless status.succeeded?
+      log_dsc_exception(status.stderr) unless status.succeeded?
       configuration_update_required?(status.return_value)
     end
 
@@ -77,7 +77,7 @@ class Chef::Util::DSC
         ps4_base_command
       else
         if ps_version_gte_5?
-          "#{common_command_prefix} Test-DscConfiguration -path #{@configuration_path}"
+          "#{common_command_prefix} Test-DscConfiguration -path #{@configuration_path} | format-list"
         else
           ps4_base_command + " -whatif; if (! $?) { exit 1 }"
         end
@@ -88,31 +88,31 @@ class Chef::Util::DSC
       Chef::Platform.supported_powershell_version?(@node, 5)
     end
 
-    def log_what_if_exception(what_if_exception_output)
-      if whatif_not_supported?(what_if_exception_output)
+    def log_dsc_exception(dsc_exception_output)
+      if whatif_not_supported?(dsc_exception_output)
         # LCM returns an error if any of the resources do not support the opptional What-If
         Chef::Log.warn("Received error while testing configuration due to resource not supporting 'WhatIf'")
-      elsif dsc_module_import_failure?(what_if_exception_output)
-        Chef::Log.warn("Received error while testing configuration due to a module for an imported resource possibly not being fully installed:\n#{what_if_exception_output.gsub(/\s+/, ' ')}")
+      elsif dsc_module_import_failure?(dsc_exception_output)
+        Chef::Log.warn("Received error while testing configuration due to a module for an imported resource possibly not being fully installed:\n#{dsc_exception_output.gsub(/\s+/, ' ')}")
       else
-        Chef::Log.warn("Received error while testing configuration:\n#{what_if_exception_output.gsub(/\s+/, ' ')}")
+        Chef::Log.warn("Received error while testing configuration:\n#{dsc_exception_output.gsub(/\s+/, ' ')}")
       end
     end
 
-    def whatif_not_supported?(what_if_exception_output)
-      !! (what_if_exception_output.gsub(/[\r\n]+/, "").gsub(/\s+/, " ") =~ /A parameter cannot be found that matches parameter name 'Whatif'/i)
+    def whatif_not_supported?(dsc_exception_output)
+      !! (dsc_exception_output.gsub(/[\r\n]+/, "").gsub(/\s+/, " ") =~ /A parameter cannot be found that matches parameter name 'Whatif'/i)
     end
 
-    def dsc_module_import_failure?(what_if_output)
-      !! (what_if_output =~ /\sCimException/ &&
-        what_if_output =~ /ProviderOperationExecutionFailure/ &&
-        what_if_output =~ /\smodule\s+is\s+installed/)
+    def dsc_module_import_failure?(command_output)
+      !! (command_output =~ /\sCimException/ &&
+        command_output =~ /ProviderOperationExecutionFailure/ &&
+        command_output =~ /\smodule\s+is\s+installed/)
     end
 
-    def configuration_update_required?(what_if_output)
-      Chef::Log.debug("DSC: DSC returned the following '-whatif' output from test operation:\n#{what_if_output}")
+    def configuration_update_required?(command_output)
+      Chef::Log.debug("DSC: DSC returned the following '-whatif' output from test operation:\n#{command_output}")
       begin
-        Parser.parse(what_if_output)
+        Parser.parse(command_output, ps_version_gte_5?)
       rescue Chef::Exceptions::LCMParser => e
         Chef::Log.warn("Could not parse LCM output: #{e}")
         [Chef::Util::DSC::ResourceInfo.new("Unknown DSC Resources", true, ["Unknown changes because LCM output was not parsable."])]

data/lib/chef/version.rb

@@ -21,7 +21,7 @@
 
 class Chef
   CHEF_ROOT = File.expand_path("../..", __FILE__)
-  VERSION = "12.21.14"
+  VERSION = "12.21.20"
 end
 
 #

data/spec/unit/client_spec.rb

@@ -44,6 +44,17 @@ describe Chef::Client do
     end
   end
 
+  context "when Ohai tells us to fail" do
+    it "fails" do
+      ohai_system = Ohai::System.new
+      module Ohai::Exceptions
+        class CriticalPluginFailure < Error; end
+      end
+      expect(ohai_system).to receive(:all_plugins) { raise Ohai::Exceptions::CriticalPluginFailure }
+      expect { client.run_ohai }.to raise_error(SystemExit)
+    end
+  end
+
   describe "authentication protocol selection" do
     context "when FIPS is disabled" do
       before do

data/spec/unit/provider_resolver_spec.rb

@@ -709,18 +709,21 @@ describe Chef::ProviderResolver do
 
           "rhel" => {
     #        service: [ Chef::Resource::SystemdService, Chef::Provider::Service::Systemd ],
-            package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
+            package:  [ Chef::Resource::DnfPackage, Chef::Provider::Package::Dnf ],
             ifconfig: [ Chef::Resource::Ifconfig, Chef::Provider::Ifconfig::Redhat ],
 
             %w{amazon xcp xenserver ibm_powerkvm cloudlinux parallels} => {
               "3.1.4" => {
+                package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
     #            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
               },
             },
             %w{redhat centos scientific oracle} => {
               "7.0" => {
+                package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
               },
               "6.0" => {
+                package:  [ Chef::Resource::YumPackage, Chef::Provider::Package::Yum ],
     #            service: [ Chef::Resource::RedhatService, Chef::Provider::Service::Redhat ],
               },
             },

data/spec/unit/util/dsc/lcm_output_parser_spec.rb

@@ -19,20 +19,33 @@
 require "chef/util/dsc/lcm_output_parser"
 
 describe Chef::Util::DSC::LocalConfigurationManager::Parser do
-  context "empty input parameter" do
+  context "empty input parameter for WhatIfParser" do
     it "raises an exception when there are no valid lines" do
       str = <<-EOF
 
       EOF
-      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str) }.to raise_error(Chef::Exceptions::LCMParser)
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false) }.to raise_error(Chef::Exceptions::LCMParser)
     end
 
     it "raises an exception for a nil input" do
-      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil) }.to raise_error(Chef::Exceptions::LCMParser)
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil, false) }.to raise_error(Chef::Exceptions::LCMParser)
     end
   end
 
-  context "correctly formatted output from lcm" do
+  context "empty input parameter for TestDSCParser" do
+    it "raises an exception when there are no valid lines" do
+      str = <<-EOF
+
+      EOF
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+
+    it "raises an exception for a nil input" do
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil, true) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+  end
+
+  context "correctly formatted output from lcm for WhatIfParser" do
     it "returns a single resource when only 1 logged with the correct name" do
       str = <<EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
@@ -40,7 +53,7 @@ logtype: [machinename]: LCM:  [ Start  Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources.length).to eq(1)
       expect(resources[0].name).to eq("[name]")
     end
@@ -54,7 +67,7 @@ logtype: [machinename]: LCM:  [ End    Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_truthy
     end
 
@@ -68,11 +81,11 @@ logtype: [machinename]: LCM:  [ End    Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].change_log).to match_array(["[name]", "[message]", "[name]"])
     end
 
-    it "should return false for changes_state?" do
+    it "returns false for changes_state?" do
       str = <<EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ] [name]
@@ -80,11 +93,11 @@ logtype: [machinename]: LCM:  [ Skip   Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_falsey
     end
 
-    it "should return an empty array for change_log if changes_state? is false" do
+    it "returns an empty array for change_log if changes_state? is false" do
       str = <<EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ] [name]
@@ -92,13 +105,64 @@ logtype: [machinename]: LCM:  [ Skip   Set      ] [name]
 logtype: [machinename]: LCM:  [ End    Resource ] [name]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].change_log).to be_empty
     end
   end
 
-  context "Incorrectly formatted output from LCM" do
-    it "should allow missing a [End Resource] when its the last one and still find all the resource" do
+  context "correctly formatted output from lcm for TestDSCParser" do
+    it "returns a single resource when only 1 logged with the correct name" do
+      str = <<EOF
+InDesiredState            : False
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name]
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources.length).to eq(1)
+      expect(resources[0].name).to eq("[name]")
+    end
+
+    it "identifies when a resource changes the state of the system" do
+      str = <<EOF
+InDesiredState            : False
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name]
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_truthy
+    end
+
+    it "returns false for changes_state?" do
+      str = <<EOF
+InDesiredState            : True
+ResourcesInDesiredState   : [name]
+ResourcesNotInDesiredState:
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_falsey
+    end
+
+    it "returns an empty array for change_log if changes_state? is false" do
+      str = <<EOF
+InDesiredState            : True
+ResourcesInDesiredState   : [name]
+ResourcesNotInDesiredState:
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].change_log).to be_empty
+    end
+  end
+
+  context "Incorrectly formatted output from LCM for WhatIfParser" do
+    it "allows missing [End Resource] when its the last one and still find all the resource" do
       str = <<-EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
@@ -114,12 +178,12 @@ logtype: [machinename]: LCM:  [ End    Set      ]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
 
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_falsey
       expect(resources[1].changes_state?).to be_truthy
     end
 
-    it "should allow missing a [End Resource] when its the first one and still find all the resource" do
+    it "allow missing [End Resource] when its the first one and still find all the resource" do
       str = <<-EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
@@ -135,12 +199,12 @@ logtype: [machinename]: LCM:  [ End    Resource ]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
 
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_falsey
       expect(resources[1].changes_state?).to be_truthy
     end
 
-    it "should allow missing set and end resource and assume an unconverged resource in this case" do
+    it "allows missing set and end resource and assume an unconverged resource in this case" do
       str = <<-EOF
 logtype: [machinename]: LCM:  [ Start  Set      ]
 logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
@@ -154,11 +218,31 @@ logtype: [machinename]: LCM:  [ End    Set      ]
 logtype: [machinename]: LCM:  [ End    Resource ]
 logtype: [machinename]: LCM:  [ End    Set      ]
 EOF
-      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str)
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
       expect(resources[0].changes_state?).to be_truthy
       expect(resources[0].name).to eql("[name]")
       expect(resources[1].changes_state?).to be_truthy
       expect(resources[1].name).to eql("[name2]")
     end
   end
+
+  context "Incorrectly formatted output from LCM for TestDSCParser" do
+    it "allows missing [End Resource] when its the last one and still find all the resource" do
+      str = <<EOF
+InDesiredState            : True
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name]
+ReturnValue               : 0
+PSComputerName            : .
+InDesiredState            : True
+ResourcesInDesiredState   :
+ResourcesNotInDesiredState: [name2]
+ReturnValue               : 0
+PSComputerName            : .
+EOF
+
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_falsey
+    end
+  end
 end

data/spec/unit/util/dsc/local_configuration_manager_spec.rb

@@ -57,6 +57,7 @@ EOH
     context "when interacting with the LCM using a PowerShell cmdlet" do
       before(:each) do
         allow(lcm).to receive(:run_configuration_cmdlet).and_return(lcm_status)
+        allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
       end
       context "that returns successfully" do
         let(:lcm_standard_output) { normal_lcm_output }
@@ -103,7 +104,7 @@ EOH
         let(:common_command_prefix) { "$ProgressPreference = 'SilentlyContinue';" }
         let(:ps4_base_command) { "#{common_command_prefix} Start-DscConfiguration -path tmp -wait -erroraction 'stop' -force" }
         let(:lcm_command_ps4) { ps4_base_command + " -whatif; if (! $?) { exit 1 }" }
-        let(:lcm_command_ps5) { "#{common_command_prefix} Test-DscConfiguration -path tmp" }
+        let(:lcm_command_ps5) { "#{common_command_prefix} Test-DscConfiguration -path tmp | format-list" }
         let(:lcm_standard_output) { normal_lcm_output }
         let(:lcm_standard_error) { nil }
         let(:lcm_cmdlet_success) { true }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef
 version: !ruby/object:Gem::Version
-  version: 12.21.14
+  version: 12.21.20
 platform: universal-mingw32
 authors:
 - Adam Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-27 00:00:00.000000000 Z
+date: 2017-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-config
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 12.21.14
+        version: 12.21.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 12.21.14
+        version: 12.21.20
 - !ruby/object:Gem::Dependency
   name: mixlib-cli
   requirement: !ruby/object:Gem::Requirement