puppet 3.8.2-x64-mingw32 → 3.8.3-x64-mingw32

data/lib/puppet/pops/validation/checker4_0.rb

@@ -296,6 +296,12 @@ class Puppet::Pops::Validation::Checker4_0
     'runtime' => true,
   }
 
+  FUTURE_RESERVED_WORDS = {
+    'application' => true,
+    'produces' => true,
+    'consumes' => true
+  }
+
   # for 'class', 'define', and function
   def check_NamedDefinition(o)
     top(o.eContainer, o)
@@ -307,6 +313,12 @@ class Puppet::Pops::Validation::Checker4_0
       acceptor.accept(Issues::RESERVED_TYPE_NAME, o, {:name => o.name})
     end
 
+    # This is perhaps not ideal but it's very difficult to pass a ReservedWord through
+    # the mechanism that creates qualified names (namestack, namepop etc.)
+    if FUTURE_RESERVED_WORDS[o.name]
+      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, {:word => o.name})
+    end
+
     if violator = ends_with_idem(o.body)
       acceptor.accept(Issues::IDEM_NOT_ALLOWED_LAST, violator, {:container => o})
     end

data/lib/puppet/provider/exec.rb

@@ -56,7 +56,12 @@ class Puppet::Provider::Exec < Puppet::Provider
           exec_user = resource[:user]
         end
 
-        Timeout::timeout(resource[:timeout]) do
+        # Ruby 2.1 and later interrupt execution in a way that bypasses error
+        # handling by default. Passing Timeout::Error causes an exception to be
+        # raised that can be rescued inside of the block by cleanup routines.
+        #
+        # This is backwards compatible all the way to Ruby 1.8.7.
+        Timeout.timeout(resource[:timeout], Timeout::Error) do
           # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
           # default/system locale will be respected.  Callers may override this behavior by setting locale-related
           # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.

data/lib/puppet/provider/service/launchd.rb

@@ -66,12 +66,27 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     ]
   end
 
+  # Gets the current Darwin version, example 10.6 returns 9 and 10.10 returns 14
+  # See https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
+  # for more information.
+  #
+  # @api private
+  def self.get_os_version
+    @os_version ||= Facter.value(:operatingsystemmajrelease).to_i
+  end
+
   # Defines the path to the overrides plist file where service enabling
   # behavior is defined in 10.6 and greater.
   #
+  # With the rewrite of launchd in 10.10+, this moves and slightly changes format.
+  #
   # @api private
   def self.launchd_overrides
-    "/var/db/launchd.db/com.apple.launchd/overrides.plist"
+    if self.get_os_version < 14
+      "/var/db/launchd.db/com.apple.launchd/overrides.plist"
+    else
+      "/var/db/com.apple.xpc.launchd/disabled.plist"
+    end
   end
 
   # Caching is enabled through the following three methods. Self.prefetch will
@@ -181,11 +196,9 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # it is 10.6 or greater. This allows us to implement different plist
   # behavior for versions >= 10.6
   def has_macosx_plist_overrides?
-    @product_version ||= self.class.get_macosx_version_major
     # (#11593) Remove support for OS X 10.4 & earlier
     # leaving this as is because 10.5 still didn't have plist support
-    return true unless /^10\.[0-5]/.match(@product_version)
-    return false
+    return self.class.get_os_version > 9
   end
 
   # Read a plist, whether its format is XML or in Apple's "binary1"
@@ -246,8 +259,10 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     did_enable_job = false
     cmds = []
     cmds << :launchctl << :load
+    # always add -w so it always starts the job, it is a noop if it is not needed, this means we do
+    # not have to rescan all launchd plists.
+    cmds << "-w"
     if self.enabled? == :false  || self.status == :stopped # launchctl won't load disabled jobs
-      cmds << "-w"
       did_enable_job = true
     end
     cmds << job_path
@@ -305,7 +320,11 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     if has_macosx_plist_overrides?
       if FileTest.file?(self.class.launchd_overrides) and overrides = self.class.read_plist(self.class.launchd_overrides)
         if overrides.has_key?(resource[:name])
-          overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
+          if self.class.get_os_version < 14
+            overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
+          else
+            overrides_disabled = overrides[resource[:name]]
+          end
         end
       end
     end
@@ -328,7 +347,11 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   def enable
     if has_macosx_plist_overrides?
       overrides = self.class.read_plist(self.class.launchd_overrides)
-      overrides[resource[:name]] = { "Disabled" => false }
+      if self.class.get_os_version < 14
+        overrides[resource[:name]] = { "Disabled" => false }
+      else
+        overrides[resource[:name]] = false
+      end
       Plist::Emit.save_plist(overrides, self.class.launchd_overrides)
     else
       job_path, job_plist = plist_from_label(resource[:name])
@@ -342,7 +365,11 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   def disable
     if has_macosx_plist_overrides?
       overrides = self.class.read_plist(self.class.launchd_overrides)
-      overrides[resource[:name]] = { "Disabled" => true }
+      if self.class.get_os_version < 14
+        overrides[resource[:name]] = { "Disabled" => true }
+      else
+        overrides[resource[:name]] = true
+      end
       Plist::Emit.save_plist(overrides, self.class.launchd_overrides)
     else
       job_path, job_plist = plist_from_label(resource[:name])

data/lib/puppet/resource/catalog.rb

@@ -168,10 +168,6 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       transaction.report.as_logging_destination do
         transaction.evaluate
       end
-    rescue Puppet::Error => detail
-      Puppet.log_exception(detail, "Could not apply complete catalog: #{detail}")
-    rescue => detail
-      Puppet.log_exception(detail, "Got an uncaught exception of type #{detail.class}: #{detail}")
     ensure
       # Don't try to store state unless we're a host config
       # too recursive.

data/lib/puppet/util/execution.rb

@@ -1,3 +1,4 @@
+require 'timeout'
 require 'puppet/file_system/uniquefile'
 
 module Puppet
@@ -179,8 +180,23 @@ module Puppet::Util::Execution
       if execution_stub = Puppet::Util::ExecutionStub.current_value
         return execution_stub.call(*exec_args)
       elsif Puppet.features.posix?
-        child_pid = execute_posix(*exec_args)
-        exit_status = Process.waitpid2(child_pid).last.exitstatus
+        child_pid = nil
+        begin
+          child_pid = execute_posix(*exec_args)
+          exit_status = Process.waitpid2(child_pid).last.exitstatus
+          child_pid = nil
+        rescue Timeout::Error => e
+          # NOTE: For Ruby 2.1+, an explicit Timeout::Error class has to be
+          # passed to Timeout.timeout in order for there to be something for
+          # this block to rescue.
+          unless child_pid.nil?
+            Process.kill(:TERM, child_pid)
+            # Spawn a thread to reap the process if it dies.
+            Thread.new { Process.waitpid(child_pid) }
+          end
+
+          raise e
+        end
       elsif Puppet.features.microsoft_windows?
         process_info = execute_windows(*exec_args)
         begin

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.8.2'
+  PUPPETVERSION = '3.8.3'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/transaction_spec.rb

@@ -205,7 +205,7 @@ describe Puppet::Transaction do
     notify.expects(:pre_run_check).raises(Puppet::Error, "fail for testing")
 
     catalog = mk_catalog(file, notify)
-    catalog.apply
+    expect { catalog.apply }.to raise_error(Puppet::Error, /Some pre-run checks failed/)
     Puppet::FileSystem.exist?(path).should_not be_true
   end
 

data/spec/integration/type/file_spec.rb

@@ -1053,7 +1053,6 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
           @sids = {
             :current_user => Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name),
             :system => Win32::Security::SID::LocalSystem,
-            :admin => Puppet::Util::Windows::SID.name_to_sid("Administrator"),
             :guest => Puppet::Util::Windows::SID.name_to_sid("Guest"),
             :users => Win32::Security::SID::BuiltinUsers,
             :power_users => Win32::Security::SID::PowerUsers,

data/spec/integration/util/windows/security_spec.rb

@@ -15,7 +15,6 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
     @sids = {
       :current_user => Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name),
       :system => Win32::Security::SID::LocalSystem,
-      :admin => Puppet::Util::Windows::SID.name_to_sid("Administrator"),
       :administrators => Win32::Security::SID::BuiltinAdministrators,
       :guest => Puppet::Util::Windows::SID.name_to_sid("Guest"),
       :users => Win32::Security::SID::BuiltinUsers,
@@ -386,9 +385,14 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         end
 
         describe "#owner=" do
+          it "should accept the guest sid" do
+            winsec.set_owner(sids[:guest], path)
+            expect(winsec.get_owner(path)).to eq(sids[:guest])
+          end
+
           it "should accept a user sid" do
-            winsec.set_owner(sids[:admin], path)
-            winsec.get_owner(path).should == sids[:admin]
+            winsec.set_owner(sids[:current_user], path)
+            winsec.get_owner(path).should == sids[:current_user]
           end
 
           it "should accept a group sid" do
@@ -406,14 +410,19 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         end
 
         describe "#group=" do
+          it "should accept the test group" do
+            winsec.set_group(sids[:guest], path)
+            expect(winsec.get_group(path)).to eq(sids[:guest])
+          end
+
           it "should accept a group sid" do
             winsec.set_group(sids[:power_users], path)
             winsec.get_group(path).should == sids[:power_users]
           end
 
           it "should accept a user sid" do
-            winsec.set_group(sids[:admin], path)
-            winsec.get_group(path).should == sids[:admin]
+            winsec.set_group(sids[:current_user], path)
+            winsec.get_group(path).should == sids[:current_user]
           end
 
           it "should combine owner and group rights when they are the same sid" do

data/spec/unit/pops/validator/validator_spec.rb

@@ -125,6 +125,21 @@ describe "validating 4x" do
         source = "$a = #{word}"
         expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
       end
+
+      it 'produces a warning issue when used as a class name' do
+        source = "class #{word} {}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::FUTURE_RESERVED_WORD)
+      end
+
+      it 'produces no warning or error when used as a parameter name' do
+        source = "define foo($#{word}) { notice $#{word} }"
+        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
+      end
+
+      it 'produces no warning or error when used as an attribute name' do
+        source = "foo { bar: #{word} => ok }"
+        expect(validate(parse(source)).diagnostics.empty?).to eq(true)
+      end
     end
   end
 

data/spec/unit/provider/service/launchd_spec.rb

@@ -6,8 +6,9 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:launchd) do
   let (:joblabel) { "com.foo.food" }
   let (:provider) { subject.class }
-  let (:launchd_overrides) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
   let(:resource) { Puppet::Type.type(:service).new(:name => joblabel, :provider => :launchd) }
+  let (:launchd_overrides_6_9) { '/var/db/launchd.db/com.apple.launchd/overrides.plist' }
+  let (:launchd_overrides_10_) { '/var/db/com.apple.xpc.launchd/disabled.plist' }
   subject { resource.provider }
 
   describe "the type interface" do
@@ -39,42 +40,70 @@ describe Puppet::Type.type(:service).provider(:launchd) do
 
   describe "when checking whether the service is enabled on OS X 10.5" do
     it "should return true in if the job plist says disabled is false" do
-      subject.expects(:has_macosx_plist_overrides?).returns(false)
+      provider.expects(:get_os_version).returns(9)
       subject.expects(:plist_from_label).with(joblabel).returns(["foo", {"Disabled" => false}])
+      provider.expects(:read_plist).never
       subject.enabled?.should == :true
     end
     it "should return true in if the job plist has no disabled key" do
-      subject.expects(:has_macosx_plist_overrides?).returns(false)
+      provider.expects(:get_os_version).returns(9)
       subject.expects(:plist_from_label).returns(["foo", {}])
       subject.enabled?.should == :true
     end
     it "should return false in if the job plist says disabled is true" do
       subject.expects(:has_macosx_plist_overrides?).returns(false)
       subject.expects(:plist_from_label).returns(["foo", {"Disabled" => true}])
+      provider.expects(:read_plist).never
       subject.enabled?.should == :false
     end
   end
 
-  describe "when checking whether the service is enabled on OS X 10.6" do
+  [[10, '10.6'], [13, '10.9']].each do |kernel, version|
+    describe "when checking whether the service is enabled on OS X #{version}" do
+      it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        subject.enabled?.should == :true
+      end
+      it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        subject.enabled?.should == :false
+      end
+      it "should return true if the job plist and the global overrides have no disabled keys" do
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {}])
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
+        subject.enabled?.should == :true
+      end
+    end
+  end
+
+  describe "when checking whether the service is enabled on OS X 10.10" do
     it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
-      provider.expects(:get_macosx_version_major).returns("10.6")
+      provider.expects(:get_os_version).returns(14).at_least_once
       subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
-      provider.expects(:read_plist).returns({joblabel => {"Disabled" => false}})
-      FileTest.expects(:file?).with(launchd_overrides).returns(true)
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => false})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       subject.enabled?.should == :true
     end
     it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
-      provider.expects(:get_macosx_version_major).returns("10.6")
+      provider.expects(:get_os_version).returns(14).at_least_once
       subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
-      provider.expects(:read_plist).returns({joblabel => {"Disabled" => true}})
-      FileTest.expects(:file?).with(launchd_overrides).returns(true)
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({joblabel => true})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       subject.enabled?.should == :false
     end
     it "should return true if the job plist and the global overrides have no disabled keys" do
-      provider.expects(:get_macosx_version_major).returns("10.6")
+      provider.expects(:get_os_version).returns(14).at_least_once
       subject.expects(:plist_from_label).returns([joblabel, {}])
-      provider.expects(:read_plist).returns({})
-      FileTest.expects(:file?).with(launchd_overrides).returns(true)
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       subject.enabled?.should == :true
     end
   end
@@ -89,13 +118,13 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     it "should look for the relevant plist once" do
       subject.expects(:plist_from_label).returns([joblabel, {}]).once
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel])
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel])
       subject.start
     end
     it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
       subject.expects(:plist_from_label).returns([joblabel, {}])
       subject.expects(:enabled?).returns :true
-      subject.expects(:execute).with([:launchctl, :load, joblabel]).once
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel]).once
       subject.start
     end
     it "should execute 'launchctl load' with writing to the plist once if the job is disabled" do
@@ -189,23 +218,45 @@ describe Puppet::Type.type(:service).provider(:launchd) do
     end
   end
 
-  describe "when enabling the service on OS X 10.6" do
+  [[10, "10.6"], [13, "10.9"]].each do |kernel, version|
+    describe "when enabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = true
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
+        subject.enable
+      end
+    end
+
+    describe "when disabling the service on OS X #{version}" do
+      it "should write to the global launchd overrides file once" do
+        resource[:enable] = false
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        provider.expects(:read_plist).with(launchd_overrides_6_9).returns({})
+        Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
+        subject.disable
+      end
+    end
+  end
+
+  describe "when enabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = true
-      provider.expects(:get_macosx_version_major).returns("10.6")
-      provider.expects(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
+      provider.expects(:get_os_version).returns(14).at_least_once
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], false), launchd_overrides_10_).once
       subject.enable
     end
   end
 
-  describe "when disabling the service on OS X 10.6" do
+  describe "when disabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = false
-      provider.stubs(:get_macosx_version_major).returns("10.6")
-      provider.stubs(:read_plist).returns({})
-      Plist::Emit.expects(:save_plist).once
-      subject.enable
+      provider.expects(:get_os_version).returns(14).at_least_once
+      provider.expects(:read_plist).with(launchd_overrides_10_).returns({})
+      Plist::Emit.expects(:save_plist).with(has_entry(resource[:name], true), launchd_overrides_10_).once
+      subject.disable
     end
   end
 

data/spec/unit/type/exec_spec.rb

@@ -396,16 +396,24 @@ describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should fail if timeout is exceeded" do
-        ruby_path = Puppet::Util::Execution.ruby_path()
+      describe 'when timeout is exceeded' do
+        subject do
+          ruby_path = Puppet::Util::Execution.ruby_path()
+          Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 1'", :timeout => '0.1')
+        end
 
-        ## Leaving this commented version in here because it fails on windows, due to what appears to be
-        ##  an assumption about hash iteration order in lib/puppet/type.rb#hash2resource, where
-        ##  resource[]= will overwrite the namevar with ":name" if the iteration is in the wrong order
-        #sleep_exec = Puppet::Type.type(:exec).new(:name => 'exec_spec sleep command', :command => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
-        sleep_exec = Puppet::Type.type(:exec).new(:name => "#{ruby_path} -e 'sleep 0.02'", :timeout => '0.01')
+        context 'on POSIX', :unless => Puppet.features.microsoft_windows? do
+          it 'sends a SIGTERM and raises a Puppet::Error' do
+            Process.expects(:kill).at_least_once
+            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+          end
+        end
 
-        expect { sleep_exec.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+        context 'on Windows', :if => Puppet.features.microsoft_windows? do
+          it 'raises a Puppet::Error' do
+            expect { subject.refresh }.to raise_error Puppet::Error, "Command exceeded timeout"
+          end
+        end
       end
 
       it "should convert timeout to a float" do