puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/node/facts.rb

@@ -78,12 +78,17 @@ class Puppet::Node::Facts
     strip_internal == other.send(:strip_internal)
   end
 
-  def self.from_pson(data)
+  def self.from_data_hash(data)
     new_facts = allocate
     new_facts.initialize_from_hash(data)
     new_facts
   end
 
+  def self.from_pson(data)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(data)
+  end
+
   def to_data_hash
     result = {
       'name' => name,
@@ -109,10 +114,6 @@ class Puppet::Node::Facts
     result
   end
 
-  def to_pson(*args)
-    to_data_hash.to_pson(*args)
-  end
-
   # Add internal data to the facts for storage.
   def add_timestamp
     self.timestamp = Time.now

data/lib/puppet/parameter.rb

@@ -464,7 +464,7 @@ class Puppet::Parameter
     begin
       unsafe_validate(value)
     rescue ArgumentError => detail
-      fail detail.to_s
+      self.fail Puppet::Error, detail.to_s, detail
     rescue Puppet::Error, TypeError
       raise
     rescue => detail

data/lib/puppet/parser/ast.rb

@@ -36,7 +36,6 @@ class Puppet::Parser::AST
   # Evaluate the current object.  Just a stub method, since the subclass
   # should override this method.
   def evaluate(*options)
-    raise Puppet::DevError, "Did not override #evaluate in #{self.class}"
   end
 
   # Throw a parse error.
@@ -128,3 +127,4 @@ require 'puppet/parser/ast/resourceparam'
 require 'puppet/parser/ast/selector'
 require 'puppet/parser/ast/tag'
 require 'puppet/parser/ast/vardef'
+require 'puppet/parser/code_merger'

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

@@ -8,12 +8,7 @@ class Puppet::Parser::AST
     def evaluate(scope)
       result = nil
       @children.each do |child|
-        # Skip things that respond to :instantiate (classes, nodes,
-        # and definitions), because they have already been
-        # instantiated.
-        if !child.respond_to?(:instantiate)
-          result = child.safeevaluate(scope)
-        end
+        result = child.safeevaluate(scope)
       end
       result
     end

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

@@ -8,8 +8,16 @@ class Puppet::Parser::AST
 class CollExpr < AST::Branch
   attr_accessor :test1, :test2, :oper, :form, :type, :parens
 
-  # We return an object that does a late-binding evaluation.
   def evaluate(scope)
+    if Puppet[:parser] == 'future'
+      evaluate4x(scope)
+    else
+      evaluate3x(scope)
+    end
+  end
+
+  # We return an object that does a late-binding evaluation.
+  def evaluate3x(scope)
     # Make sure our contained expressions have all the info they need.
     [@test1, @test2].each do |t|
       if t.is_a?(self.class)
@@ -48,9 +56,53 @@ class CollExpr < AST::Branch
     return match, code
   end
 
+  # Late binding evaluation of a collect expression (as done in 3x), but with proper Puppet Langauge
+  # semantics for equals and include
+  #
+  def evaluate4x(scope)
+    # Make sure our contained expressions have all the info they need.
+    [@test1, @test2].each do |t|
+      if t.is_a?(self.class)
+        t.form ||= self.form
+        t.type ||= self.type
+      end
+    end
+
+    # The code is only used for virtual lookups
+    match1, code1 = @test1.safeevaluate scope
+    match2, code2 = @test2.safeevaluate scope
+
+    # First build up the virtual code.
+    # If we're a conjunction operator, then we're calling code.  I did
+    # some speed comparisons, and it's at least twice as fast doing these
+    # case statements as doing an eval here.
+    code = proc do |resource|
+      case @oper
+      when "and"; code1.call(resource) and code2.call(resource)
+      when "or"; code1.call(resource) or code2.call(resource)
+      when "=="
+        if match1 == "tag"
+          resource.tagged?(match2)
+        else
+          if resource[match1].is_a?(Array)
+            @@compare_operator.include?(resource[match1], match2)
+          else
+            @@compare_operator.equals(resource[match1], match2)
+          end
+        end
+      when "!="; ! @@compare_operator.equals(resource[match1], match2)
+      end
+    end
+
+    match = [match1, @oper, match2]
+    return match, code
+  end
+
   def initialize(hash = {})
     super
-
+    if Puppet[:parser] == "future"
+      @@compare_operator ||= Puppet::Pops::Evaluator::CompareOperator.new
+    end
     raise ArgumentError, "Invalid operator #{@oper}" unless %w{== != and or}.include?(@oper)
   end
 end

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

@@ -122,5 +122,14 @@ class Puppet::Parser::AST
       result << "| ... }"
       result.join('')
     end
+
+    # marker method checked with respond_to :puppet_lambda
+    def puppet_lambda()
+      true
+    end
+
+    def parameter_names
+      @parameters.collect {|p| p[0] }
+    end
   end
 end

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

@@ -169,6 +169,8 @@ class Puppet::Parser::AST
         raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
       end
 
+      mutation_deprecation()
+
       # assign to hash or array
       object[array_index_or_key(object, accesskey)] = value
     end
@@ -176,6 +178,19 @@ class Puppet::Parser::AST
     def to_s
       "\$#{variable.to_s}[#{key.to_s}]"
     end
+
+    def mutation_deprecation
+      deprecation_location_text =
+      if file && line
+        " at #{file}:#{line}"
+      elsif file
+        " in file #{file}"
+      elsif line
+        " at #{line}"
+      end
+      Puppet.warning(["The use of mutating operations on Array/Hash is deprecated#{deprecation_location_text}.",
+         " See http://links.puppetlabs.com/puppet-mutation-deprecation"].join(''))
+    end
   end
 
   class Regex < AST::Leaf

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

@@ -0,0 +1,168 @@
+require 'puppet/parser/ast/top_level_construct'
+require 'puppet/pops'
+
+# The AST::Bridge contains classes that bridges between the new Pops based model
+# and the 3.x AST. This is required to be able to reuse the Puppet::Resource::Type which is
+# fundamental for the rest of the logic.
+#
+class Puppet::Parser::AST::PopsBridge
+
+  # Bridges to one Pops Model Expression
+  # The @value is the expression
+  # This is used to represent the body of a class, definition, or node, and for each parameter's default value
+  # expression.
+  #
+  class Expression < Puppet::Parser::AST::Leaf
+
+    def initialize args
+      super
+      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser::Transitional.new()
+    end
+
+    def to_s
+      Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
+    end
+
+    def evaluate(scope)
+      @@evaluator.evaluate(scope, @value)
+    end
+
+    # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
+    # by yielding self. By adding this there is no need to wrap a pops expression inside an AST::BlockExpression
+    #
+    def each
+      yield self
+    end
+
+    def sequence_with(other)
+      if value.nil?
+        # This happens when testing and not having a complete setup
+        other
+      else
+        # When does this happen ? Ever ?
+        raise "sequence_with called on Puppet::Parser::AST::PopsBridge::Expression - please report use case"
+        # What should be done if the above happens (We don't want this to happen).
+        # Puppet::Parser::AST::BlockExpression.new(:children => [self] + other.children)
+      end
+    end
+
+    # The 3x requires code plugged in to an AST to have this in certain positions in the tree. The purpose
+    # is to either print the content, or to look for things that needs to be defined. This implementation
+    # cheats by always returning an empty array. (This allows simple files to not require a "Program" at the top.
+    #
+    def children
+      []
+    end
+  end
+
+  # Bridges the top level "Program" produced by the pops parser.
+  # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
+  # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
+  # are not created, that happens when classes are included / required, nodes are matched and when resources are instantiated
+  # by a resource expression (which is also used to instantiate a host class).
+  #
+  class Program < Puppet::Parser::AST::TopLevelConstruct
+    attr_reader :program_model, :context
+
+    def initialize(program_model, context = {})
+      @program_model = program_model
+      @context = context
+      @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
+      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser::Transitional.new()
+    end
+
+    # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
+    # This Pops-model based instantiation relies on the parser to build this list while parsing (which is more
+    # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
+    #
+    def instantiate(modname)
+      @program_model.definitions.collect do |d|
+        case d
+        when Puppet::Pops::Model::HostClassDefinition
+          instantiate_HostClassDefinition(d, modname)
+        when Puppet::Pops::Model::ResourceTypeDefinition
+          instantiate_ResourceTypeDefinition(d, modname)
+        when Puppet::Pops::Model::NodeDefinition
+          instantiate_NodeDefinition(d, modname)
+        else
+          raise Puppet::ParseError("Internal Error: Unknown type of definition - got '#{d.class}'")
+        end
+      end.flatten() # flatten since node definition may have returned an array
+    end
+
+    def evaluate(scope)
+      @@evaluator.evaluate(scope, program_model)
+    end
+
+    # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
+    # by yielding self. This means that the HostClass container will call this bridge instance with `instantiate`.
+    #
+    def each
+      yield self
+    end
+
+    private
+
+    def instantiate_Parameter(o)
+      # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
+      # One problem is that the parameter evaluation takes place in the wrong context in 3x (the caller's and
+      # can thus reference all sorts of information. Here the value expression is wrapped in an AST Bridge to a Pops
+      # expression since the Pops side can not control the evaluation
+      if o.value
+        [ o.name, Expression.new(:value => o.value) ]
+      else
+        [ o.name ]
+      end
+    end
+
+    # Produces a hash with data for Definition and HostClass
+    def args_from_definition(o, modname)
+      args = {
+       :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
+       :module_name => modname
+      }
+      unless is_nop?(o.body)
+        args[:code] = Expression.new(:value => o.body)
+      end
+      @ast_transformer.merge_location(args, o)
+    end
+
+    def instantiate_HostClassDefinition(o, modname)
+      args = args_from_definition(o, modname)
+      args[:parent] = o.parent_class
+      Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
+    end
+
+    def instantiate_ResourceTypeDefinition(o, modname)
+      Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
+    end
+
+    def instantiate_NodeDefinition(o, modname)
+      args = { :module_name => modname }
+
+      unless is_nop?(o.body)
+        args[:code] = Expression.new(:value => o.body)
+      end
+
+      unless is_nop?(o.parent)
+        args[:parent] = @ast_transformer.hostname(o.parent)
+      end
+
+      host_matches = @ast_transformer.hostname(o.host_matches)
+      @ast_transformer.merge_location(args, o)
+      host_matches.collect do |name|
+        Puppet::Resource::Type.new(:node, name, @context.merge(args))
+      end
+    end
+
+    def code()
+      Expression.new(:value => @value)
+    end
+
+    def is_nop?(o)
+      @ast_transformer.is_nop?(o)
+    end
+
+  end
+
+end

data/lib/puppet/parser/code_merger.rb

@@ -0,0 +1,13 @@
+
+class Puppet::Parser::CodeMerger
+
+  # Concatenates the logic in the array of parse results into one parse result
+  # @return Puppet::Parser::AST::BlockExpression
+  #
+  def concatenate(parse_results)
+    children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
+      memo + parsed_class.code.children
+    end
+    Puppet::Parser::AST::BlockExpression.new(:children => children)
+  end
+end

data/lib/puppet/parser/collector.rb

@@ -103,7 +103,7 @@ class Puppet::Parser::Collector
 
       # key is '#{type}/#{name}', and host and filter.
       found = Puppet::Resource.indirection.
-        search(@type, :host => @scope.host, :filter => @equery, :scope => @scope)
+        search(@type, :host => @scope.compiler.node.name, :filter => @equery, :scope => @scope)
 
       found_resources = found.map {|x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope)}
 

data/lib/puppet/parser/compiler.rb

@@ -98,42 +98,40 @@ class Puppet::Parser::Compiler
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
-    # Set the client's parameters into the top scope.
-    Puppet::Util::Profiler.profile("Compile: Set node parameters") { set_node_parameters }
+    Puppet.override({ :current_environment => environment }, "For compiling #{node.name}") do
+      # Set the client's parameters into the top scope.
+      Puppet::Util::Profiler.profile("Compile: Set node parameters") { set_node_parameters }
 
-    Puppet::Util::Profiler.profile("Compile: Created settings scope") { create_settings_scope }
+      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
+      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 main") { evaluate_main }
 
-    Puppet::Util::Profiler.profile("Compile: Evaluated AST node") { evaluate_ast_node }
+      Puppet::Util::Profiler.profile("Compile: Evaluated AST node") { evaluate_ast_node }
 
-    Puppet::Util::Profiler.profile("Compile: Evaluated node classes") { evaluate_node_classes }
+      Puppet::Util::Profiler.profile("Compile: Evaluated node classes") { evaluate_node_classes }
 
-    Puppet::Util::Profiler.profile("Compile: Evaluated generators") { evaluate_generators }
+      Puppet::Util::Profiler.profile("Compile: Evaluated generators") { evaluate_generators }
 
-    Puppet::Util::Profiler.profile("Compile: Finished catalog") { finish }
+      Puppet::Util::Profiler.profile("Compile: Finished catalog") { finish }
 
-    fail_on_unevaluated
+      fail_on_unevaluated
 
-    @catalog
+      @catalog
+    end
   end
 
   def_delegator :@collections, :delete, :delete_collection
 
   # Return the node's environment.
   def environment
-    unless defined?(@environment)
-      unless node.environment.is_a? Puppet::Node::Environment
-        raise Puppet::DevError, "node #{node} has an invalid environment!"
-      end
-      @environment = node.environment
+    unless node.environment.is_a? Puppet::Node::Environment
+      raise Puppet::DevError, "node #{node} has an invalid environment!"
     end
-    Puppet::Node::Environment.current = @environment
-    @environment
+    node.environment
   end
 
   # Evaluate all of the classes specified by the node.
@@ -245,12 +243,11 @@ class Puppet::Parser::Compiler
   #
   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)
+    pb = Puppet::Pops::Binder
+    boot_contribution = pb::SystemBindings.injector_boot_contribution(env_boot_bindings)
+    final_contribution = pb::SystemBindings.final_contribution
+    binder = pb::Binder.new(pb::BindingsFactory.layered_bindings(final_contribution, boot_contribution))
+    @boot_injector = pb::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.
@@ -506,6 +503,10 @@ class Puppet::Parser::Compiler
     if Puppet[:trusted_node_data]
       @topscope.set_trusted(node.trusted_data)
     end
+    if(Puppet[:immutable_node_data])
+      facts_hash = node.facts.nil? ? {} : node.facts.values
+      @topscope.set_facts(facts_hash)
+    end
   end
 
   def create_settings_scope
@@ -543,10 +544,7 @@ class Puppet::Parser::Compiler
     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)
+    @injector = Puppet::Pops::Binder::Injector.new(Puppet::Pops::Binder::Binder.new(layered_bindings))
   end
 
   def assert_binder_active