puppet 3.6.0 → 3.6.1

data/lib/puppet/pops/parser/interpolation_support.rb

@@ -208,7 +208,7 @@ module Puppet::Pops::Parser::InterpolationSupport
 
   def transform_to_variable(token)
     token_name = token[0]
-    if [:NUMBER, :NAME].include?(token_name) || self.class::KEYWORD_NAMES[token_name]
+    if [:NUMBER, :NAME, :WORD].include?(token_name) || self.class::KEYWORD_NAMES[token_name]
       t = token[1]
       ta = t.token_array
       [:VARIABLE, self.class::TokenValue.new([:VARIABLE, ta[1], ta[2]], t.offset, t.locator)]

data/lib/puppet/pops/parser/lexer2.rb

@@ -87,6 +87,7 @@ class Puppet::Pops::Parser::Lexer2
 
   # Tokens that are always unique to what has been lexed
   TOKEN_STRING         =  [:STRING, nil,          0].freeze
+  TOKEN_WORD           =  [:WORD, nil,            0].freeze
   TOKEN_DQPRE          =  [:DQPRE,  nil,          0].freeze
   TOKEN_DQMID          =  [:DQPRE,  nil,          0].freeze
   TOKEN_DQPOS          =  [:DQPRE,  nil,          0].freeze
@@ -157,6 +158,7 @@ class Puppet::Pops::Parser::Lexer2
   #
   PATTERN_CLASSREF       = %r{((::){0,1}[A-Z][\w]*)+}
   PATTERN_NAME           = %r{((::)?[a-z][\w]*)(::[a-z][\w]*)*}
+
   PATTERN_BARE_WORD      = %r{[a-z_](?:[\w-]*[\w])?}
 
   PATTERN_DOLLAR_VAR     = %r{\$(::)?(\w+::)*\w+}
@@ -573,21 +575,26 @@ class Puppet::Pops::Parser::Lexer2
       end
 
     when 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '_'
       value = scn.scan(PATTERN_NAME)
-      # NAME or false start because followed by hyphen(s) and word
-      if value && !scn.match?(/-+\w/)
+      # NAME or false start because followed by hyphen(s), underscore or word
+      if value && !scn.match?(/^-+\w/)
         emit_completed(KEYWORDS[value] || [:NAME, value, scn.pos - before], before)
       else
         # Restart and check entire pattern (for ease of detecting non allowed trailing hyphen)
         scn.pos = before
         value = scn.scan(PATTERN_BARE_WORD)
-        if value
-          emit_completed([:STRING, value, scn.pos - before], before)
+        # If the WORD continues with :: it must be a correct fully qualified name
+        if value && !(fully_qualified = scn.match?(/::/))
+          emit_completed([:WORD, value, scn.pos - before], before)
         else
-          # move to faulty position ([a-z] was ok)
+          # move to faulty position ([a-z_] was ok)
           scn.pos = scn.pos + 1
-          lex_error("Illegal name")
+          if fully_qualified
+            lex_error("Illegal fully qualified name")
+          else
+            lex_error("Illegal name or bare word")
+          end
         end
       end
 

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

@@ -15,6 +15,7 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
   has_feature :versionable
   has_feature :install_options
   has_feature :uninstall_options
+  has_feature :virtual_packages
 
   # Note: self:: is required here to keep these constants in the context of what will
   # eventually become this Puppet::Type::Package::ProviderRpm class.
@@ -82,6 +83,8 @@ Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Pr
     begin
       output = rpm(*cmd)
     rescue Puppet::ExecutionFailure
+      return nil unless @resource.allow_virtual?
+
       # rpm -q exits 1 if package not found
       # retry the query for virtual packages
       cmd << '--whatprovides'

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

@@ -7,7 +7,7 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   remove dependent packages with this provider use the `purgeable` feature, but note this
   feature is destructive and should be used with the utmost care."
 
-  has_feature :install_options, :versionable
+  has_feature :install_options, :versionable, :virtual_packages
 
   commands :yum => "yum", :rpm => "rpm", :python => "python"
 
@@ -90,9 +90,14 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
   end
 
   def install
+    wanted = @resource[:name]
+    # If not allowing virtual packages, do a query to ensure a real package exists
+    unless @resource.allow_virtual?
+      yum '-d', '0', '-e', '0', '-y', :list, wanted
+    end
+
     should = @resource.should(:ensure)
     self.debug "Ensuring => #{should}"
-    wanted = @resource[:name]
     operation = :install
 
     case should
@@ -113,12 +118,15 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     yum *args
 
 
-    is = self.query
-    raise Puppet::Error, "Could not find package #{self.name}" unless is
+    # If a version was specified, query again to see if it is a matching version
+    if should
+      is = self.query
+      raise Puppet::Error, "Could not find package #{self.name}" unless is
 
-    # FIXME: Should we raise an exception even if should == :latest
-    # and yum updated us to a version other than @param_hash[:ensure] ?
-    raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should && should != is[:ensure]
+      # FIXME: Should we raise an exception even if should == :latest
+      # and yum updated us to a version other than @param_hash[:ensure] ?
+      raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should != is[:ensure]
+    end
   end
 
   # What's the latest package version available?

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

@@ -1,7 +1,7 @@
 Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
   desc "Support for SuSE `zypper` package manager. Found in SLES10sp2+ and SLES11"
 
-  has_feature :versionable, :install_options
+  has_feature :versionable, :install_options, :virtual_packages
 
   commands :zypper => "/usr/bin/zypper"
 
@@ -23,7 +23,7 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
     # XXX: We don't actually deal with epochs here.
     case should
     when true, false, Symbol
-      # pass
+      should = nil
     else
       # Add the package version
       wanted = "#{wanted}-#{should}"
@@ -52,6 +52,7 @@ Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
     #zypper 0.6.13 (OpenSuSE 10.2) does not support auto agree with licenses
     options << '--auto-agree-with-licenses' unless major < 1 and minor <= 6 and patch <= 13
     options << '--no-confirm'
+    options << '--name' unless @resource.allow_virtual? || should
     options += install_options if resource[:install_options]
     options << wanted
 

data/lib/puppet/ssl/host.rb

@@ -203,7 +203,7 @@ DOC
 
       # get the CA cert first, since it's required for the normal cert
       # to be of any use.
-      return nil unless Certificate.indirection.find("ca") unless ca?
+      return nil unless Certificate.indirection.find("ca", :fail_on_404 => true) unless ca?
       return nil unless @certificate = Certificate.indirection.find(name)
 
       validate_certificate_with_key

data/lib/puppet/test/test_helper.rb

@@ -36,6 +36,19 @@ module Puppet::Test
     # that call Puppet.
     # @return nil
     def self.initialize()
+      # This meta class instance variable is used as a guard to ensure that
+      # before_each, and after_each are only called once. This problem occurs
+      # when there are more than one puppet test infrastructure "orchestrator in us.
+      # The use of both puppetabs-spec_helper, and rodjek-rspec_puppet will cause
+      # two resets of the puppet environment, and will cause problem rolling back to
+      # a known point as there is no way to differentiate where the calls are coming
+      # from. See more information in #before_each_test, and #after_each_test
+      # Note that the variable is only initialized to 0 if nil. This is important
+      # as more than one orchestrator will call initialize. A second call can not
+      # simply set it to 0 since that would potentially destroy an active guard.
+      #
+      @@reentry_count ||= 0
+
       owner = Process.pid
       Puppet.push_context(Puppet.base_context({
         :environmentpath => "",
@@ -58,9 +71,24 @@ module Puppet::Test
     def self.after_all_tests()
     end
 
+    # The name of the rollback mark used in the Puppet.context. This is what
+    # the test infrastructure returns to for each test.
+    #
+    ROLLBACK_MARK = "initial testing state"
+
     # Call this method once per test, prior to execution of each invididual test.
     # @return nil
     def self.before_each_test()
+      # When using both rspec-puppet and puppet-rspec-helper, there are two packages trying
+      # to be helpful and orchestrate the callback sequence. We let only the first win, the
+      # second callback results in a no-op.
+      # Likewise when entering after_each_test(), a check is made to make tear down happen
+      # only once.
+      #
+      return unless @@reentry_count == 0
+      @@reentry_count = 1
+
+      Puppet.mark_context(ROLLBACK_MARK)
 
       # We need to preserve the current state of all our indirection cache and
       # terminus classes.  This is pretty important, because changes to these
@@ -112,6 +140,11 @@ module Puppet::Test
     # Call this method once per test, after execution of each individual test.
     # @return nil
     def self.after_each_test()
+      # Ensure that a matching tear down only happens once per completed setup
+      # (see #before_each_test).
+      return unless @@reentry_count == 1
+      @@reentry_count = 0
+
       Puppet.settings.send(:clear_everything_for_tests)
 
       Puppet::Util::Storage.clear
@@ -153,7 +186,7 @@ module Puppet::Test
       $LOAD_PATH.clear
       $old_load_path.each {|x| $LOAD_PATH << x }
 
-      Puppet.pop_context
+      Puppet.rollback_context(ROLLBACK_MARK)
     end
 
 

data/lib/puppet/type/package.rb

@@ -4,6 +4,7 @@
 # systems.
 
 require 'puppet/parameter/package_options'
+require 'puppet/parameter/boolean'
 
 module Puppet
   newtype(:package) do
@@ -54,7 +55,7 @@ module Puppet
       ensured for the given package. The meaning and format of these settings is
       provider-specific.",
       :methods => [:package_settings_insync?, :package_settings, :package_settings=]
-
+    feature :virtual_packages, "The provider accepts virtual package names for install and uninstall."
 
     ensurable do
       desc <<-EOT
@@ -421,6 +422,16 @@ module Puppet
       EOT
     end
 
+    newparam(:allow_virtual, :boolean => true, :parent => Puppet::Parameter::Boolean, :required_features => :virtual_packages) do
+      desc 'Specifies if virtual package names are allowed for install and uninstall.'
+
+      # In a future release, this should be defaulted to true and the below deprecation warning removed
+      defaultto do
+        Puppet.deprecation_warning('The package type\'s allow_virtual parameter will be changing its default value from false to true in a future release. If you do not want to allow virtual packages, please explicitly set allow_virtual to false.') unless value
+        false
+      end
+    end
+
     autorequire(:file) do
       autos = []
       [:responsefile, :adminfile].each { |param|

data/lib/puppet/version.rb

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

data/spec/unit/configurer_spec.rb

@@ -204,19 +204,25 @@ describe Puppet::Configurer do
     end
 
     it "should send the report" do
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
       @agent.expects(:send_report).with(report)
 
+      report.environment.should == "test"
+      report.transaction_uuid.should == "aaaa"
+
       @agent.run
     end
 
     it "should send the transaction report even if the catalog could not be retrieved" do
       @agent.expects(:retrieve_catalog).returns nil
 
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report)
+      @agent.expects(:send_report).with(report)
+
+      report.environment.should == "test"
+      report.transaction_uuid.should == "aaaa"
 
       @agent.run
     end
@@ -224,9 +230,12 @@ describe Puppet::Configurer do
     it "should send the transaction report even if there is a failure" do
       @agent.expects(:retrieve_catalog).raises "whatever"
 
-      report = Puppet::Transaction::Report.new("apply")
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
       Puppet::Transaction::Report.expects(:new).returns(report)
-      @agent.expects(:send_report)
+      @agent.expects(:send_report).with(report)
+
+      report.environment.should == "test"
+      report.transaction_uuid.should == "aaaa"
 
       @agent.run.should be_nil
     end
@@ -254,7 +263,7 @@ describe Puppet::Configurer do
 
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
-      @agent.expects(:send_report)
+      @agent.expects(:send_report).with(report)
 
       @agent.run.should be_nil
     end
@@ -276,7 +285,7 @@ describe Puppet::Configurer do
 
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util::Execution.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
-      @agent.expects(:send_report)
+      @agent.expects(:send_report).with(report)
 
       @agent.run.should be_nil
     end
@@ -351,6 +360,19 @@ describe Puppet::Configurer do
       @agent.environment.should == "second_env"
     end
 
+    it "should fix the report if the server specifies a new environment in the catalog" do
+      report = Puppet::Transaction::Report.new("apply", nil, "test", "aaaa")
+      Puppet::Transaction::Report.expects(:new).returns(report)
+      @agent.expects(:send_report).with(report)
+
+      @catalog.stubs(:environment).returns("second_env")
+      @agent.stubs(:retrieve_catalog).returns(@catalog)
+
+      @agent.run
+
+      report.environment.should == "second_env"
+    end
+
     it "should clear the global caches" do
       $env_module_directories = false
 
@@ -508,6 +530,13 @@ describe Puppet::Configurer do
     end
   end
 
+  describe "when requesting a node" do
+    it "uses the transaction uuid in the request" do
+      Puppet::Node.indirection.expects(:find).with(anything, has_entries(:transaction_uuid => anything)).twice
+      @agent.run
+    end
+  end
+
   describe "when retrieving a catalog" do
     before do
       Puppet.settings.stubs(:use).returns(true)

data/spec/unit/context_spec.rb

@@ -72,6 +72,45 @@ describe Puppet::Context do
     end
   end
 
+  context "a rollback" do
+    it "returns to the mark" do
+      context.push("a" => 1)
+      context.mark("start")
+      context.push("a" => 2)
+      context.push("a" => 3)
+      context.pop
+
+      context.rollback("start")
+
+      expect(context.lookup("a")).to eq(1)
+    end
+
+    it "rolls back to the mark across a scoped override" do
+      context.push("a" => 1)
+      context.mark("start")
+      context.override("a" => 3) do
+
+        context.rollback("start")
+
+        expect(context.lookup("a")).to eq(1)
+      end
+      expect(context.lookup("a")).to eq(1)
+    end
+
+    it "fails to rollback to an unknown mark" do
+      expect do
+        context.rollback("unknown")
+      end.to raise_error(Puppet::Context::UnknownRollbackMarkError)
+    end
+
+    it "does not allow the same mark to be set twice" do
+      context.mark("duplicate")
+      expect do
+        context.mark("duplicate")
+      end.to raise_error(Puppet::Context::DuplicateRollbackMarkError)
+    end
+  end
+
   context 'support lazy entries' do
     it 'by evaluating a bound proc' do
       result = nil

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -191,6 +191,22 @@ describe Puppet::Resource::Catalog::Compiler do
 
       compiler.find(request)
     end
+
+    it "should pass the transaction_uuid to the node indirection" do
+      uuid = '793ff10d-89f8-4527-a645-3302cbc749f3'
+      node = Puppet::Node.new("thing")
+      compiler = Puppet::Resource::Catalog::Compiler.new
+      compiler.stubs(:compile)
+      request = Puppet::Indirector::Request.new(:catalog, :find, "thing",
+                                                nil, :transaction_uuid => uuid)
+
+      Puppet::Node.indirection.expects(:find).with(
+        "thing",
+        has_entries(:transaction_uuid => uuid)
+      ).returns(node)
+
+      compiler.find(request)
+    end
   end
 
   describe "after finding nodes" do

data/spec/unit/indirector/rest_spec.rb

@@ -277,12 +277,26 @@ describe Puppet::Indirector::REST do
       terminus.find(request).should == nil
     end
 
-    it 'raises a warning for a 404' do
+    it 'raises no warning for a 404 (when not asked to do so)' do
       response = mock_response('404', 'this is the notfound you are looking for')
       connection.expects(:get).returns(response)
       expected_message = 'Find /production/test_model/foo? resulted in 404 with the message: this is the notfound you are looking for'
-      Puppet::Util::Warnings.expects(:maybe_log).with(expected_message, Puppet::TestModel::Rest)
-      terminus.find(request)
+      expect{terminus.find(request)}.to_not raise_error()
+    end
+
+    context 'when fail_on_404 is used in request' do
+      let(:request) { find_request('foo', :fail_on_404 => true) }
+
+      it 'raises an error for a 404 when asked to do so' do
+        response = mock_response('404', 'this is the notfound you are looking for')
+        connection.expects(:get).returns(response)
+        expected_message = [
+          'Find /production/test_model/foo?fail_on_404=true',
+          'resulted in 404 with the message: this is the notfound you are looking for'].join( ' ')
+        expect do
+          terminus.find(request)
+        end.to raise_error(Puppet::Error, expected_message)
+      end
     end
 
     it "asks the model to deserialize the response body and sets the name on the resulting object to the find key" do