puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/node/facts.rb

@@ -28,6 +28,7 @@ class Puppet::Node::Facts
   def add_local_facts
     values["clientcert"] = Puppet.settings[:certname]
     values["clientversion"] = Puppet.version.to_s
+    values["clientnoop"] = Puppet.settings[:noop]
   end
 
   def initialize(name, values = {})
@@ -64,6 +65,14 @@ class Puppet::Node::Facts
     end
   end
 
+  # Sanitize fact values by converting everything not a string, boolean
+  # numeric, array or hash into strings.
+  def sanitize
+    values.each do |fact, value|
+      values[fact] = sanitize_fact value
+    end
+  end
+
   def ==(other)
     return false unless self.name == other.name
     strip_internal == other.send(:strip_internal)
@@ -93,11 +102,11 @@ class Puppet::Node::Facts
   end
 
   def timestamp=(time)
-    self.values[:_timestamp] = time
+    self.values['_timestamp'] = time
   end
 
   def timestamp
-    self.values[:_timestamp]
+    self.values['_timestamp']
   end
 
   private
@@ -108,4 +117,21 @@ class Puppet::Node::Facts
     newvals.find_all { |name, value| name.to_s =~ /^_/ }.each { |name, value| newvals.delete(name) }
     newvals
   end
+
+  def sanitize_fact(fact)
+    if fact.is_a? Hash then
+      ret = {}
+      fact.each_pair { |k,v| ret[sanitize_fact k]=sanitize_fact v }
+      ret
+    elsif fact.is_a? Array then
+      fact.collect { |i| sanitize_fact i }
+    elsif fact.is_a? Numeric \
+      or fact.is_a? TrueClass \
+      or fact.is_a? FalseClass \
+      or fact.is_a? String
+      fact
+    else
+      fact.to_s
+    end
+  end
 end

data/lib/puppet/parameter.rb

@@ -1,5 +1,4 @@
 require 'puppet/util/methodhelper'
-require 'puppet/util/log_paths'
 require 'puppet/util/logging'
 require 'puppet/util/docs'
 
@@ -22,7 +21,6 @@ require 'puppet/util/docs'
 class Puppet::Parameter
   include Puppet::Util
   include Puppet::Util::Errors
-  include Puppet::Util::LogPaths
   include Puppet::Util::Logging
   include Puppet::Util::MethodHelper
 
@@ -241,10 +239,11 @@ class Puppet::Parameter
     end
 
     # @overload validate {|| ... }
-    # Defines an optional method that is used to validate the parameter's value.
+    # Defines an optional method that is used to validate the parameter's DSL/string value.
     # Validation should raise appropriate exceptions, the return value of the given block is ignored.
     # The easiest way to raise an appropriate exception is to call the method {Puppet::Util::Errors.fail} with
     # the message as an argument.
+    # To validate the munged value instead, just munge the value (`munge(value)`).
     #
     # @return [void]
     # @dsl type
@@ -306,19 +305,29 @@ class Puppet::Parameter
   #
   attr_accessor :parent
 
-  # @!method line()
-  #   @return [Integer] Returns the result of calling the same method on the associated resource.
-  # @!method file
-  #   @return [Integer] Returns the result of calling the same method on the associated resource.
-  # @!method version
-  #   @return [Integer] Returns the result of calling the same method on the associated resource.
-  #
-  [:line, :file, :version].each do |param|
-    define_method(param) do
-      resource.send(param)
-    end
+  # Returns a string representation of the resource's containment path in
+  # the catalog.
+  # @return [String]
+  def path
+    @path ||= '/' + pathbuilder.join('/')
   end
 
+  # @return [Integer] Returns the result of calling the same method on the associated resource.
+  def line
+    resource.line
+  end
+
+  # @return [Integer] Returns the result of calling the same method on the associated resource.
+  def file
+    resource.file
+  end
+
+  # @return [Integer] Returns the result of calling the same method on the associated resource.
+  def version
+    resource.version
+  end
+
+
   # Initializes the parameter with a required resource reference and optional attribute settings.
   # The option `:resource` must be specified or an exception is raised. Any additional options passed
   # are used to initialize the attributes of this parameter by treating each key in the `options` hash as
@@ -377,9 +386,9 @@ class Puppet::Parameter
     tmp
   end
 
-  # @todo Original comment = _return the full path to us, for logging and rollback; not currently
-  #   used_ This is difficult to figure out (if it is used or not as calls are certainly made to "pathbuilder"
-  #   method is several places, not just sure if it is this implementation or not.
+  # Returns an array of strings representing the containment heirarchy
+  # (types/classes) that make up the path to the resource from the root
+  # of the catalog.  This is mostly used for logging purposes.
   #
   # @api private
   def pathbuilder
@@ -477,7 +486,7 @@ class Puppet::Parameter
   # @todo This original comment _"All of the checking should possibly be
   #   late-binding (e.g., users might not exist when the value is assigned
   #   but might when it is asked for)."_ does not seem to be correct, the implementation
-  #   calls both validate an munge on the given value, so no late binding.
+  #   calls both validate and munge on the given value, so no late binding.
   #
   # The given value is validated and then munged (if munging has been specified). The result is store
   # as the value of this arameter.

data/lib/puppet/parameter/boolean.rb

@@ -0,0 +1,20 @@
+# This specialized {Puppet::Parameter} handles boolean options, accepting lots
+# of strings and symbols for both truthiness and falsehood.
+#
+class Puppet::Parameter::Boolean < Puppet::Parameter
+  def unsafe_munge(value)
+    # downcase strings
+    if value.respond_to? :downcase
+      value = value.downcase
+    end
+
+    case value
+    when true, :true, 'true', :yes, 'yes'
+      true
+    when false, :false, 'false', :no, 'no'
+      false
+    else
+      fail('expected a boolean value')
+    end
+  end
+end

data/lib/puppet/parameter/path.rb

@@ -45,7 +45,7 @@ class Puppet::Parameter::Path < Puppet::Parameter
   # This default implementation does not perform any munging, it just checks the one/many paths
   # constraints. A derived implementation can perform this check as:
   # `paths.is_a?(Array) and ! self.class.arrays?` and raise a {Puppet::Error}.
-  # @param [String, Array<String>] one of multiple paths
+  # @param paths [String, Array<String>] one of multiple paths
   # @return [String, Array<String>] the given paths
   # @raise [Puppet::Error] if the given paths does not comply with the on/many paths rule.
   def unsafe_munge(paths)

data/lib/puppet/parameter/value.rb

@@ -34,7 +34,7 @@ class Puppet::Parameter::Value
 
   # Initializes the instance with a literal accepted value, or a regular expression.
   # If anything else is passed, it is turned into a String, and then made into a Symbol.
-  # @param [Symbol, Regexp, Object] the value to accept, Symbol, a regular expression, or object to convert.
+  # @param name [Symbol, Regexp, Object] the value to accept, Symbol, a regular expression, or object to convert.
   # @api private
   #
   def initialize(name)

data/lib/puppet/parameter/value_collection.rb

@@ -189,7 +189,7 @@ class Puppet::Parameter::ValueCollection
   end
 
   # Returns a valid value matcher (a literal or regular expression)
-  # @todo This looks odd, asking for an instance that matches a symbol, or a instance that has
+  # @todo This looks odd, asking for an instance that matches a symbol, or an instance that has
   #   a regexp. What is the intention here? Marking as api private...
   #
   # @return [Puppet::Parameter::Value] a valid valud matcher

data/lib/puppet/parser/ast/arithmetic_operator.rb

@@ -80,4 +80,12 @@ class Puppet::Parser::AST
       raise ArgumentError, "Invalid arithmetic operator #{@operator}" unless %w{+ - * / % << >>}.include?(@operator)
     end
   end
+
+  # Used by future parser instead of ArithmeticOperator to enable concatenation
+  class ArithmeticOperator2 < ArithmeticOperator
+    # Overrides the arithmetic operator to allow concatenation
+    def assert_concatenation_supported
+    end
+  end
+
 end

data/lib/puppet/parser/ast/casestatement.rb

@@ -15,9 +15,6 @@ class Puppet::Parser::AST
 
       value = @test.safeevaluate(scope)
 
-      retvalue = nil
-      found = false
-
       # Iterate across the options looking for a match.
       default = nil
       @options.each do |option|

data/lib/puppet/parser/ast/lambda.rb

@@ -36,31 +36,50 @@ class Puppet::Parser::AST
     #
     def call(scope, *args)
       raise Puppet::ParseError, "Too many arguments: #{args.size} for #{parameters.size}" unless args.size <= parameters.size
+
+      # associate values with parameters
       merged = parameters.zip(args)
-      missing = merged.select { |e| !e[1] && e[0].size == 1 }
+      # calculate missing arguments
+      missing = parameters.slice(args.size, parameters.size - args.size).select {|e| e.size == 1}
       unless missing.empty?
         optional = parameters.count { |p| p.size == 2 }
         raise Puppet::ParseError, "Too few arguments; #{args.size} for #{optional > 0 ? ' min ' : ''}#{parameters.size - optional}"
       end
 
       evaluated = merged.collect do |m|
-        # Ruby 1.8.7 zip seems to produce a different result than Ruby 1.9.3 in some situations
-        n = m[0].is_a?(Array) ? m[0][0] : m[0]
-        v = m[1] || (m[0][1]).safeevaluate(scope) # given value or default expression value
-        [n, v]
+        # m can be one of
+        # m = [["name"], "given"]
+        #   | [["name", default_expr], "given"]
+        #
+        # "given" is always an optional entry. If a parameter was provided then
+        # the entry will be in the array, otherwise the m array will be a
+        # single element.
+        given_argument = m[1]
+        argument_name = m[0][0]
+        default_expression = m[0][1]
+
+        value = if m.size == 1
+          default_expression.safeevaluate(scope)
+        else
+          given_argument
+        end
+        [argument_name, value]
       end
 
       # Store the evaluated name => value associations in a new inner/local/ephemeral scope
       # (This is made complicated due to the fact that the implementation of scope is overloaded with
       # functionality and an inner ephemeral scope must be used (as opposed to just pushing a local scope
       # on a scope "stack").
+
+      # Ensure variable exists with nil value if error occurs. 
+      # Some ruby implementations does not like creating variable on return
+      result = nil
       begin
         elevel = scope.ephemeral_level
         scope.ephemeral_from(Hash[evaluated], file, line)
         result = safeevaluate(scope)
       ensure
         scope.unset_ephemeral_var(elevel)
-        result ||= nil
       end
       result
     end

data/lib/puppet/parser/ast/leaf.rb

@@ -131,7 +131,13 @@ class Puppet::Parser::AST
 
     def evaluate_container(scope)
       container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
-      (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope[container, {:file => file, :line => line}]
+      if container.is_a?(Hash) || container.is_a?(Array)
+        container
+      elsif container.is_a?(::String)
+        scope[container, {:file => file, :line => line}]
+      else
+        raise Puppet::ParseError, "#{variable} is #{container.inspect}, not a hash or array"
+      end
     end
 
     def evaluate_key(scope)
@@ -148,9 +154,10 @@ class Puppet::Parser::AST
     def evaluate(scope)
       object = evaluate_container(scope)
       accesskey = evaluate_key(scope)
-      raise Puppet::ParseError, "#{variable} is not an hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
+      raise Puppet::ParseError, "#{variable} is not a hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
 
-      object[array_index_or_key(object, accesskey)] || :undef
+      result = object[array_index_or_key(object, accesskey)]
+      result.nil? ? :undef : result
     end
 
     # Assign value to this hashkey or array index

data/lib/puppet/parser/ast/nop.rb

@@ -2,7 +2,7 @@ require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
   # This class is a no-op, it doesn't produce anything
-  # when evaluated, hence it's name :-)
+  # when evaluated, hence its name :-)
   class Nop < AST::Leaf
     def evaluate(scope)
       # nothing to do

data/lib/puppet/parser/ast/resource_override.rb

@@ -23,8 +23,6 @@ class Puppet::Parser::AST
       # Get our object reference.
       resource = @object.safeevaluate(scope)
 
-      hash = {}
-
       # Evaluate all of the specified params.
       params = @parameters.collect { |param|
         param.safeevaluate(scope)

data/lib/puppet/parser/compiler.rb

@@ -35,6 +35,22 @@ class Puppet::Parser::Compiler
 
   attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
 
+  # The injector that provides lookup services, or nil if accessed before the compiler has started compiling and
+  # bootstrapped. The injector is initialized and available before any manifests are evaluated.
+  #
+  # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services for this compiler/environment
+  # @api public
+  #
+  attr_accessor :injector
+
+  # The injector that provides lookup services during the creation of the {#injector}.
+  # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services during injector creation
+  #   for this compiler/environment
+  #
+  # @api private
+  #
+  attr_accessor :boot_injector
+
   # Add a collection to the global list.
   def_delegator :@collections,   :<<, :add_collection
   def_delegator :@relationships, :<<, :add_relationship
@@ -51,7 +67,6 @@ class Puppet::Parser::Compiler
     end
   end
 
-  # Store a resource in our resource table.
   def add_resource(scope, resource)
     @resources << resource
 
@@ -94,6 +109,10 @@ class Puppet::Parser::Compiler
 
     Puppet::Util::Profiler.profile("Compile: Created settings scope") { create_settings_scope }
 
+    if is_binder_active?
+      Puppet::Util::Profiler.profile("Compile: Created injector") { create_injector }
+    end
+
     Puppet::Util::Profiler.profile("Compile: Evaluated main") { evaluate_main }
 
     Puppet::Util::Profiler.profile("Compile: Evaluated AST node") { evaluate_ast_node }
@@ -135,7 +154,7 @@ class Puppet::Parser::Compiler
   #
   # Sometimes we evaluate classes with a fully qualified name already, in which
   # case, we tell scope.find_hostclass we've pre-qualified the name so it
-  # doesn't need to search it's namespaces again.  This gets around a weird
+  # doesn't need to search its namespaces again.  This gets around a weird
   # edge case of duplicate class names, one at top scope and one nested in our
   # namespace and the wrong one (or both!) getting selected. See ticket #13349
   # for more detail.  --jeffweiss 26 apr 2012
@@ -197,6 +216,47 @@ class Puppet::Parser::Compiler
     @resource_overrides[resource.ref]
   end
 
+  def injector
+    create_injector if @injector.nil?
+    @injector
+  end
+
+  def boot_injector
+    create_boot_injector(nil) if @boot_injector.nil?
+    @boot_injector
+  end
+
+  # Creates the boot injector from registered system, default, and injector config.
+  # @return [Puppet::Pops::Binder::Injector] the created boot injector
+  # @api private Cannot be 'private' since it is called from the BindingsComposer.
+  #
+  def create_boot_injector(env_boot_bindings)
+    assert_binder_active()
+    boot_contribution = Puppet::Pops::Binder::SystemBindings.injector_boot_contribution(env_boot_bindings)
+    final_contribution = Puppet::Pops::Binder::SystemBindings.final_contribution
+    binder = Puppet::Pops::Binder::Binder.new()
+    binder.define_categories(boot_contribution.effective_categories)
+    binder.define_layers(Puppet::Pops::Binder::BindingsFactory.layered_bindings(final_contribution, boot_contribution))
+    @boot_injector = Puppet::Pops::Binder::Injector.new(binder)
+  end
+
+  # Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.
+  # @return [Boolean] true if the Puppet Binder should be activated
+  def is_binder_active?
+    should_be_active = Puppet[:binder] || Puppet[:parser] == 'future'
+    if should_be_active
+      # TODO: this should be in a central place, not just for ParserFactory anymore...
+      Puppet::Parser::ParserFactory.assert_rgen_installed()
+      @@binder_loaded ||= false
+      unless @@binder_loaded
+        require 'puppet/pops'
+        require 'puppetx'
+        @@binder_loaded = true
+      end
+    end
+    should_be_active
+  end
+
   private
 
   # If ast nodes are enabled, then see if we can find and evaluate one.
@@ -303,16 +363,11 @@ class Puppet::Parser::Compiler
   # not find the resource they were supposed to override, so we
   # want to throw an exception.
   def fail_on_unevaluated_overrides
-    remaining = []
-    @resource_overrides.each do |name, overrides|
-      remaining.concat overrides
-    end
+    remaining = @resource_overrides.values.flatten.collect(&:ref)
 
-    unless remaining.empty?
+    if !remaining.empty?
       fail Puppet::ParseError,
-        "Could not find resource(s) %s for overriding" % remaining.collect { |o|
-          o.ref
-        }.join(", ")
+        "Could not find resource(s) #{remaining.join(', ')} for overriding"
     end
   end
 
@@ -320,22 +375,11 @@ class Puppet::Parser::Compiler
   # look for resources, because we want to consider those to be
   # parse errors.
   def fail_on_unevaluated_resource_collections
-    remaining = []
-    @collections.each do |coll|
-      # We're only interested in the 'resource' collections,
-      # which result from direct calls of 'realize'.  Anything
-      # else is allowed not to return resources.
-      # Collect all of them, so we have a useful error.
-      if r = coll.resources
-        if r.is_a?(Array)
-          remaining += r
-        else
-          remaining << r
-        end
-      end
-    end
+    remaining = @collections.collect(&:resources).flatten.compact
 
-    raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}" unless remaining.empty?
+    if !remaining.empty?
+      raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}"
+    end
   end
 
   # Make sure all of our resources and such have done any last work
@@ -366,10 +410,8 @@ class Puppet::Parser::Compiler
       raise "Couldn't find main"
     end
 
-    names = []
-    Puppet::Type.eachmetaparam do |name|
-      next if Puppet::Parser::Resource.relationship_parameter?(name)
-      names << name
+    names = Puppet::Type.metaparams.select do |name|
+      !Puppet::Parser::Resource.relationship_parameter?(name)
     end
 
     data = {}
@@ -405,9 +447,6 @@ class Puppet::Parser::Compiler
 
   # Set up all of our internal variables.
   def initvars
-    # The list of objects that will available for export.
-    @exported_resources = {}
-
     # The list of overrides.  This is used to cache overrides on objects
     # that don't exist yet.  We store an array of each override.
     @resource_overrides = Hash.new do |overs, ref|
@@ -430,8 +469,7 @@ class Puppet::Parser::Compiler
     # Create our initial scope and a resource that will evaluate main.
     @topscope = Puppet::Parser::Scope.new(self)
 
-    @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
-    @catalog.add_resource(@main_stage_resource)
+    @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @topscope))
 
     # local resource array to maintain resource ordering
     @resources = []
@@ -481,4 +519,24 @@ class Puppet::Parser::Compiler
     # The order of these is significant for speed due to short-circuting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
+
+  # Creates the injector from bindings found in the current environment.
+  # @return [void]
+  # @api private
+  #
+  def create_injector
+    assert_binder_active()
+    composer = Puppet::Pops::Binder::BindingsComposer.new()
+    layered_bindings = composer.compose(topscope)
+    binder = Puppet::Pops::Binder::Binder.new()
+    binder.define_categories(composer.effective_categories(topscope))
+    binder.define_layers(layered_bindings)
+    @injector = Puppet::Pops::Binder::Injector.new(binder)
+  end
+
+  def assert_binder_active
+    unless is_binder_active?
+      raise ArgumentError, "The Puppet Binder is only available when either '--binder true' or '--parser future' is used"
+    end
+  end
 end