puppet 6.8.0-universal-darwin → 6.8.1-universal-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6499c686c4bf854eadd79ed655461b3e64e9ba7a9bf9164728717c8e69679748
-  data.tar.gz: 34fff83b7811ccf9bf0cec90ab5c6fb4d4251b2cfeaa5331d8d6fb01860db2ff
+  metadata.gz: d00a3b2f05395e3c6a8d3ff02af9c37d9ff1f59983b97219f0b089d0df510777
+  data.tar.gz: 18c3ddf076de1cfcb3e8dd7d032bfcd5f7089ad548623966fae3af49ff0157cb
 SHA512:
-  metadata.gz: d856db8d30bc8a77198998525cfb5dea36db856096862ffba21cc2d8792de03c8575b8e5dc065f6351412f5c081f6a8b8e537750f58f0f95022dec218c0d882f
-  data.tar.gz: 36f03ab60e5ffe8126c4dafcae83cfe51bf3798fd460077b468bedea14c135d52f681867f99a013aea266a5bc6e84124f698527b214a060b06c7653f670c9815
+  metadata.gz: 52f05e562d12e02df2900fb04552ba317f88eecd10638de68b7106ab3f3c9231affe0064fc502fc9ac5c258224ec714a183ca1865a29d2271e63335afaaa5671
+  data.tar.gz: 5c491e73bc2364918af10ef0d39230997014c0e1d71f776a3f23e724bdb994e06d5d67f666d56466c64a80390ec101af84a87f179825b42fbbcbfb8ceadb5558

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    puppet (6.8.0)
+    puppet (6.8.1)
       CFPropertyList (~> 2.2)
       facter (>= 2.4.0, < 4)
       fast_gettext (~> 1.1)
@@ -23,7 +23,7 @@ GEM
     crack (0.4.3)
       safe_yaml (~> 1.0.0)
     diff-lcs (1.3)
-    facter (2.5.5)
+    facter (2.5.6)
     fast_gettext (1.1.2)
     gettext (3.2.9)
       locale (>= 2.0.5)
@@ -51,7 +51,7 @@ GEM
     multi_json (1.13.1)
     mustache (1.1.0)
     optimist (3.0.0)
-    packaging (0.99.38)
+    packaging (0.99.39)
       artifactory (~> 2)
       rake (~> 12.3)
     parallel (1.17.0)

data/lib/puppet/provider/package/apt.rb

@@ -8,7 +8,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     These options should be specified as an array where each element is either a
      string or a hash."
 
-  has_feature :versionable, :install_options, :virtual_packages
+  has_feature :versionable, :install_options
 
   commands :aptget => "/usr/bin/apt-get"
   commands :aptcache => "/usr/bin/apt-cache"

data/lib/puppet/provider/package/dpkg.rb

@@ -5,7 +5,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
     and not `apt`, you must specify the source of any packages you want
     to manage."
 
-  has_feature :holdable, :virtual_packages 
+  has_feature :holdable
 
   commands :dpkg => "/usr/bin/dpkg"
   commands :dpkg_deb => "/usr/bin/dpkg-deb"
@@ -45,18 +45,16 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
   # Note: self:: is required here to keep these constants in the context of what will
   # eventually become this Puppet::Type::Package::ProviderDpkg class.
   self::DPKG_QUERY_FORMAT_STRING = %Q{'${Status} ${Package} ${Version}\\n'}
-  self::DPKG_QUERY_PROVIDES_FORMAT_STRING = %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}
   self::FIELDS_REGEX = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*)$}
-  self::FIELDS_REGEX_WITH_PROVIDES = %r{^(\S+) +(\S+) +(\S+) (\S+) (\S*) \[.*\]$} 
   self::FIELDS= [:desired, :error, :status, :name, :ensure]
 
   # @param line [String] one line of dpkg-query output
   # @return [Hash,nil] a hash of FIELDS or nil if we failed to match
   # @api private
-  def self.parse_line(line, regex=self::FIELDS_REGEX)
+  def self.parse_line(line)
     hash = nil
 
-    match = regex.match(line)
+    match = self::FIELDS_REGEX.match(line)
     if match
       hash = {}
 
@@ -118,18 +116,6 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
 
     # list out our specific package
     begin
-      if @resource.allow_virtual?
-        output = dpkgquery(
-          "-W",
-          "--showformat",
-          self.class::DPKG_QUERY_PROVIDES_FORMAT_STRING
-        ).lines.find {|package| package.match(/\[.*#{@resource[:name]}.*\]/)}
-        if output          
-          hash = self.class.parse_line(output,self.class::FIELDS_REGEX_WITH_PROVIDES)
-          Puppet.info("Package #{@resource[:name]} is virtual, defaulting to #{hash[:name]}")
-          @resource[:name] = hash[:name]
-        end
-      end
       output = dpkgquery(
         "-W",
         "--showformat",

data/lib/puppet/util/execution.rb

@@ -162,15 +162,16 @@ module Puppet::Util::Execution
 
     options = default_options.merge(options)
 
-    if options[:sensitive]
-      command_str = '[redacted]'
-    elsif command.is_a?(Array)
+    if command.is_a?(Array)
       command = command.flatten.map(&:to_s)
       command_str = command.join(" ")
     elsif command.is_a?(String)
       command_str = command
     end
 
+    # do this after processing 'command' array or string
+    command_str = '[redacted]' if options[:sensitive]
+
     user_log_s = ''
     if options[:uid]
       user_log_s << " uid=#{options[:uid]}"

data/lib/puppet/version.rb

@@ -6,7 +6,7 @@
 # Raketasks and such to set the version based on the output of `git describe`
 
 module Puppet
-  PUPPETVERSION = '6.8.0'
+  PUPPETVERSION = '6.8.1'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/util/execution_spec.rb

@@ -25,7 +25,34 @@ describe Puppet::Util::Execution, unless: Puppet::Util::Platform.jruby? do
     end
   end
 
-  describe "#execute (non-Windows)", :if => !Puppet::Util::Platform.windows? do
+  describe "#execute" do
+    if Puppet::Util::Platform.windows?
+      let(:argv) { ["cmd", "/c", "echo", 123] }
+    else
+      let(:argv) { ["echo", 123] }
+    end
+
+    it 'stringifies sensitive arguments when given an array containing integers' do
+      result = Puppet::Util::Execution.execute(argv, sensitive: true)
+      expect(result.to_s.strip).to eq("123")
+      expect(result.exitstatus).to eq(0)
+    end
+
+    it 'redacts sensitive arguments when given an array' do
+      Puppet[:log_level] = :debug
+      Puppet::Util::Execution.execute(argv, sensitive: true)
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'"))
+    end
+
+    it 'redacts sensitive arguments when given a string' do
+      Puppet[:log_level] = :debug
+      str = argv.map(&:to_s).join(' ')
+      Puppet::Util::Execution.execute(str, sensitive: true)
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'"))
+    end
+  end
+
+  describe "#execute (non-Windows)", :if => !Puppet.features.microsoft_windows? do
     it "should execute basic shell command" do
       result = Puppet::Util::Execution.execute("ls /tmp", :failonfail => true)
       expect(result.exitstatus).to eq(0)

data/spec/unit/provider/package/dpkg_spec.rb

@@ -8,7 +8,6 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
   let(:vim_installed_output) { "install ok installed vim 2:7.3.547-6ubuntu5\n" }
   let(:all_installed_io) { StringIO.new([bash_installed_output, vim_installed_output].join) }
   let(:args) { ['-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}] }
-  let(:args_with_provides) { ['/bin/dpkg-query','-W', '--showformat', %Q{'${Status} ${Package} ${Version} [${Provides}]\\n'}]}
   let(:execute_options) do
     {:failonfail => true, :combine => true, :custom_environment => {}}
   end
@@ -32,6 +31,7 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
 
       installed = double('bash')
       expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(installed)
+
       expect(described_class.instances).to eq([installed])
     end
 
@@ -68,59 +68,31 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
     end
 
-    def dpkg_query_execution_with_multiple_args_returns(output, *args)
-      args.each do |arg|
-        expect(Puppet::Util::Execution).to receive(:execute).with(arg, execute_options).ordered.and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
-      end
-    end
-
     before do
       allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
-      allow(resource).to receive(:allow_virtual?).and_return(false)
     end
 
     it "considers the package purged if dpkg-query fails" do
       allow(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
-      expect(provider.query[:ensure]).to eq(:purged)
-    end
 
-    it "considers the package purged if dpkg-query fails  with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      allow(Puppet::Util::Execution).to receive(:execute).with(args_with_provides, execute_options).and_raise(Puppet::ExecutionFailure.new("eh"))
       expect(provider.query[:ensure]).to eq(:purged)
     end
 
     it "returns a hash of the found package status for an installed package" do
       dpkg_query_execution_returns(bash_installed_output)
-      expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
-    end
 
-    it "returns a hash of the found package status for an installed package with allo_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns(bash_installed_output,args_with_provides,query_args)
       expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
     end
 
     it "considers the package absent if the dpkg-query result cannot be interpreted" do
-      allow(resource).to receive(:allow_virtual?).and_return(false)
       dpkg_query_execution_returns('some-bad-data')
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
 
-    it "considers the package absent if the dpkg-query result cannot be interpreted  with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns('some-bad-data',args_with_provides,query_args)
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
     it "fails if an error is discovered" do
       dpkg_query_execution_returns(bash_installed_output.gsub("ok","error"))
-      expect { provider.query }.to raise_error(Puppet::Error)
-    end
 
-    it "fails if an error is discovered with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns(bash_installed_output.gsub("ok","error"),args_with_provides,query_args)
       expect { provider.query }.to raise_error(Puppet::Error)
     end
 
@@ -128,74 +100,35 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
       not_installed_bash.gsub!(bash_version, "")
       dpkg_query_execution_returns(not_installed_bash)
-      expect(provider.query[:ensure]).to eq(:purged)
-    end
 
-    it "considers the package purged if it is marked 'not-installed' with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
-      not_installed_bash.gsub!(bash_version, "")
-      dpkg_query_execution_with_multiple_args_returns(not_installed_bash,args_with_provides,query_args)
       expect(provider.query[:ensure]).to eq(:purged)
     end
 
-
     it "considers the package absent if it is marked 'config-files'" do
       dpkg_query_execution_returns(bash_installed_output.gsub("installed","config-files"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "considers the package absent if it is marked 'config-files' with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns(bash_installed_output.gsub("installed","config-files"),args_with_provides,query_args)
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
-
     it "considers the package absent if it is marked 'half-installed'" do
       dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-installed"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "considers the package absent if it is marked 'half-installed' with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns(bash_installed_output.gsub("installed","half-installed"),args_with_provides,query_args)
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
-
     it "considers the package absent if it is marked 'unpacked'" do
       dpkg_query_execution_returns(bash_installed_output.gsub("installed","unpacked"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-
-    it "considers the package absent if it is marked 'unpacked' with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns(bash_installed_output.gsub("installed","unpacked"),args_with_provides,query_args)
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
-
     it "considers the package absent if it is marked 'half-configured'" do
       dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-configured"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "considers the package absent if it is marked 'half-configured' with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns(bash_installed_output.gsub("installed","half-configured"),args_with_provides,query_args)      
-      expect(provider.query[:ensure]).to eq(:absent)
-    end
-
     it "considers the package held if its state is 'hold'" do
       dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
       expect(provider.query[:ensure]).to eq(:held)
     end
 
-    it "considers the package held if its state is 'hold' with allow_virtual enabled" do
-      allow(resource).to receive(:allow_virtual?).and_return(true)
-      dpkg_query_execution_with_multiple_args_returns(bash_installed_output.gsub("install","hold"),args_with_provides,query_args)
-      expect(provider.query[:ensure]).to eq(:held)
-    end
-
     context "parsing tests" do
       let(:resource_name) { 'name' }
       let(:package_hash) do
@@ -211,7 +144,6 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
       let(:package_not_found_hash) do
         {:ensure => :purged, :status => 'missing', :name => resource_name, :error => 'ok'}
       end
-      let(:output) {'an unexpected dpkg msg with an exit code of 0'}
 
       def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
         dpkg_query_execution_returns(dpkg_output_string)
@@ -225,33 +157,20 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
         no_ensure = 'desired ok status name '
         parser_test(no_ensure, package_hash.merge(:ensure => ''))
       end
-      it "provides debug logging of unparsable lines with allow_virtual enabled" do
-        allow(resource).to receive(:allow_virtual?).and_return(true)
-        dpkg_query_execution_with_multiple_args_returns(output, args_with_provides, query_args)
-        expect(Puppet).not_to receive(:warning)
-        expect(Puppet).to receive(:debug).exactly(1).times
-        expect(provider.query).to eq(package_not_found_hash.merge(:ensure => :absent))
-      end
-      
 
       it "provides debug logging of unparsable lines" do
         parser_test('an unexpected dpkg msg with an exit code of 0', package_not_found_hash.merge(:ensure => :absent), 1)
       end
-      
-      it "does not log if execution returns with non-zero exit code with allow_virtual enabled" do
-        allow(resource).to receive(:allow_virtual?).and_return(true)
-        expect(Puppet::Util::Execution).to receive(:execute).with(args_with_provides, execute_options).ordered.and_raise(Puppet::ExecutionFailure.new("failed"))
-        expect(Puppet).not_to receive(:debug)
-        expect(provider.query).to eq(package_not_found_hash)
-      end
 
       it "does not log if execution returns with non-zero exit code" do
         expect(Puppet::Util::Execution).to receive(:execute).with(query_args, execute_options).and_raise(Puppet::ExecutionFailure.new("failed"))
         expect(Puppet).not_to receive(:debug)
+
         expect(provider.query).to eq(package_not_found_hash)
       end
     end
   end
+
   context "when installing" do
     before do
       allow(resource).to receive(:[]).with(:source).and_return("mypkg")
@@ -373,3 +292,4 @@ describe Puppet::Type.type(:package).provider(:dpkg) do
     expect {provider.package_not_installed?("")}.to raise_error(ArgumentError,"Package name is nil or empty")
   end
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 6.8.0
+  version: 6.8.1
 platform: universal-darwin
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-19 00:00:00.000000000 Z
+date: 2019-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter