puppet 4.2.3 → 4.3.0

data/lib/puppet/pops/merge_strategy.rb

@@ -4,6 +4,8 @@ module Puppet::Pops
   # Merges to objects into one based on an implemented strategy.
   #
   class MergeStrategy
+    NOT_FOUND = Object.new.freeze
+
     TypeAsserter = Puppet::Pops::Types::TypeAsserter
     TypeParser = Puppet::Pops::Types::TypeParser
 
@@ -20,12 +22,14 @@ module Puppet::Pops
 
     # Finds the merge strategy for the given _merge_, creates an instance of it and returns that instance.
     #
-    # @param merge [String|Symbol|Hash<String,Object>] The merge strategy. Can be a string or symbol denoting the key
+    # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] The merge strategy. Can be a string or symbol denoting the key
     #   identifier or a hash with options where the key 'strategy' denotes the key
     # @return [MergeStrategy] The matching merge strategy
     #
     def self.strategy(merge)
-      TypeAsserter.assert_instance_of("MergeStrategies.merge 'merge' parameter", merge_t, merge)
+      return merge if merge.is_a?(MergeStrategy)
+      merge = :first if merge.nil?
+      TypeAsserter.assert_instance_of("MergeStrategy 'merge' parameter", merge_t, merge)
       if merge.is_a?(Hash)
         merge_strategy = merge['strategy']
         if merge_strategy.nil?
@@ -82,7 +86,7 @@ module Puppet::Pops
       @options = options
     end
 
-    # Merges the elements of _e1_ and _e2_ accoring to the implemented strategy and options given when this
+    # Merges the elements of _e1_ and _e2_ according to the rules of this strategy and options given when this
     # instance was created
     #
     # @param e1 [Object] The first element
@@ -95,6 +99,33 @@ module Puppet::Pops
         assert_type('e2', value_t, e2))
     end
 
+    # Merges the result of yielding the given _lookup_variants_ to a given block.
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value.
+    # @yield [} ]
+    # @yieldparam variant [Object] each variant given in the _lookup_variants_ array.
+    # @yieldreturn [Object] the value to merge with other values
+    # @throws :no_such_key if the lookup was unsuccessful
+    #
+    def merge_lookup(lookup_variants)
+      result = lookup_variants.reduce(NOT_FOUND) do |memo, lookup_variant|
+        not_found = true
+        value = catch(:no_such_key) do
+          v = yield(lookup_variant)
+          not_found = false
+          v
+        end
+        if not_found
+          memo
+        else
+          memo.equal?(NOT_FOUND) ? convert_value(value) : merge(memo, value)
+        end
+      end
+      throw :no_such_key if result == NOT_FOUND
+      result
+    end
+
     # Converts a single value to the type expeced when peforming a merge of two elements
     # @param value [Object] the value to convert
     # @return [Object] the converted value
@@ -102,12 +133,20 @@ module Puppet::Pops
       value
     end
 
-    protected
-
     def options
       @options
     end
 
+    def configuration
+      if @options.nil? || @options.empty?
+        self.class.key.to_s
+      else
+        @options.include?('strategy') ? @options : { 'strategy' => self.class.key.to_s }.merge(@options)
+      end
+    end
+
+    protected
+
     # Returns the type used to validate the options hash
     #
     # @return [Puppet::Pops::Types::PStructType] the puppet type
@@ -133,6 +172,35 @@ module Puppet::Pops
     end
   end
 
+  # Simple strategy that returns the first value found. It never merges any values.
+  #
+  class FirstFoundStrategy < MergeStrategy
+    def self.key
+      :first
+    end
+
+    # Returns the first value found
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value
+    # @throws :no_such_key unless the lookup was successful
+    #
+    def merge_lookup(lookup_variants)
+      lookup_variants.each do |lookup_variant|
+        catch(:no_such_key) { return yield(lookup_variant) }
+      end
+      throw :no_such_key
+    end
+
+    protected
+
+    def value_t
+      @value_t ||= Puppet::Pops::Types::PAnyType::DEFAULT
+    end
+
+    MergeStrategy.add_strategy(self)
+  end
+
   # Produces a new hash by merging hash e1 with hash e2 in such a way that the values of duplicate keys
   # will be those of e1
   #

data/lib/puppet/pops/model/factory.rb

@@ -53,6 +53,14 @@ class Puppet::Pops::Model::Factory
 
   # Building of Model classes
 
+  def build_Application(o, n, ps, body)
+    o.name = n
+    ps.each { |p| o.addParameters(build(p)) }
+    b = f_build_body(body)
+    o.body = b.current if b
+    o
+  end
+
   def build_ArithmeticExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
@@ -231,6 +239,15 @@ class Puppet::Pops::Model::Factory
     o
   end
 
+  def build_CapabilityMapping(o, kind, component, capability, mappings)
+    o.kind = kind
+    component = component.current if component.is_a?(Puppet::Pops::Model::Factory)
+    o.component = component
+    o.capability = capability
+    o.mappings = mappings.map { |m| build(m) }
+    o
+  end
+
   # @param o [Model::NodeDefinition]
   # @param hosts [Array<Expression>] host matches
   # @param parent [Expression] parent node matcher
@@ -243,6 +260,14 @@ class Puppet::Pops::Model::Factory
     o
   end
 
+  # @param o [Model::SiteDefinition]
+  # @param body [Object] see {#f_build_body}
+  def build_SiteDefinition(o, body)
+    b = f_build_body(body)
+    o.body = b.current if b
+    o
+  end
+
   def build_Parameter(o, name, expr)
     o.name = name
     o.value = build(expr) if expr # don't build a nil/nop
@@ -584,6 +609,7 @@ class Puppet::Pops::Model::Factory
 
   def self.NODE(hosts, parent, body);    new(Model::NodeDefinition, hosts, parent, body);        end
 
+  def self.SITE(body);                   new(Model::SiteDefinition, body);                       end
 
   # Parameters
 
@@ -755,6 +781,14 @@ class Puppet::Pops::Model::Factory
     new(Model::ResourceTypeDefinition, name, parameters, body)
   end
 
+  def self.CAPABILITY_MAPPING(kind, component, cap_name, mappings)
+    new(Model::CapabilityMapping, kind, component, cap_name, mappings)
+  end
+
+  def self.APPLICATION(name, parameters, body)
+    new(Model::Application, name, parameters, body)
+  end
+
   def self.FUNCTION(name, parameters, body)
     new(Model::FunctionDefinition, name, parameters, body)
   end

data/lib/puppet/pops/model/model_label_provider.rb

@@ -2,7 +2,9 @@
 # As an example, if object is an ArithmeticExpression with operator +, `#a_an(o)` produces "a '+' Expression",
 # #the(o) produces "the + Expression", and #label produces "+ Expression".
 #
-class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
+class Puppet::Pops::Model::ModelLabelProvider
+  include Puppet::Pops::LabelProvider
+
   def initialize
     @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
   end
@@ -56,6 +58,7 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_HeredocExpression o           ; "'@(#{o.syntax})' expression"       end
   def label_HostClassDefinition o         ; "Host Class Definition"             end
   def label_NodeDefinition o              ; "Node Definition"                   end
+  def label_SiteDefinition o              ; "Site Definition"                   end
   def label_ResourceTypeDefinition o      ; "'define' expression"               end
   def label_ResourceOverrideExpression o  ; "Resource Override"                 end
   def label_Parameter o                   ; "Parameter Definition"              end
@@ -64,6 +67,7 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_UnlessExpression o            ; "'unless' Statement"                end
   def label_CallNamedFunctionExpression o ; "Function Call"                     end
   def label_CallMethodExpression o        ; "Method call"                       end
+  def label_CapabilityMapping o           ; "Capability Mapping"                end
   def label_CaseExpression o              ; "'case' statement"                  end
   def label_CaseOption o                  ; "Case Option"                       end
   def label_RenderStringExpression o      ; "Epp Text"                          end
@@ -97,6 +101,11 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
     end
   end
 
+  def label_Resource o
+    'Resource Statement'
+  end
+
+
   def label_Class o
     if o <= Puppet::Pops::Types::PAnyType
       simple_name = o.name.split('::').last

data/lib/puppet/pops/model/model_meta.rb

@@ -291,6 +291,9 @@ module Puppet::Pops::Model
   class ResourceTypeDefinition < NamedDefinition
   end
 
+  class Application < NamedDefinition
+  end
+
   # A node definition matches hosts using Strings, or Regular expressions. It may inherit from
   # a parent node (also using a String or Regular expression).
   #
@@ -300,6 +303,10 @@ module Puppet::Pops::Model
     contains_one_uni 'body', Expression
   end
 
+  class SiteDefinition < Definition
+    contains_one_uni 'body', Expression
+  end
+
   class LocatableExpression < Expression
     has_many_attr 'line_offsets', Integer
     has_attr 'locator', Object, :lowerBound => 1, :transient => true
@@ -534,6 +541,14 @@ module Puppet::Pops::Model
     contains_many_uni 'bodies', ResourceBody
   end
 
+  class CapabilityMapping < Definition
+    # 'produces' or 'consumes'
+    has_attr 'kind', String, :lowerBound => 1
+    has_attr 'capability', String, :lowerBound => 1
+    contains_one_uni 'component', Expression, :lowerBound => 1
+    contains_many_uni 'mappings', AbstractAttributeOperation
+  end
+
   # A resource defaults sets defaults for a resource type. This class inherits from AbstractResource
   # but does only support the :regular form (this is intentional to be able to produce better error messages
   # when illegal forms are applied to a model.

data/lib/puppet/pops/model/model_tree_dumper.rb

@@ -32,6 +32,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     do_dump(o.current)
   end
 
+  def dump_Application o
+    ["application", o.name, do_dump(o.parameters), do_dump(o.body)]
+  end
+
   def dump_ArithmeticExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
@@ -230,6 +234,16 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_SiteDefinition o
+    result = ["site"]
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
   def dump_NamedDefinition o
     # the nil must be replaced with a string
     result = [nil, o.name]
@@ -248,6 +262,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_CapabilityMapping o
+    [o.kind, do_dump(o.component), o.capability, do_dump(o.mappings)]
+  end
+
   def dump_ResourceOverrideExpression o
     form = o.form == :regular ? '' : o.form.to_s + "-"
     result = [form+"override", do_dump(o.resources), :indent]

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

@@ -8,9 +8,21 @@ class Puppet::Pops::Parser::CodeMerger
     # this is a bit brute force as the result is already 3x ast with wrapped 4x content
     # this could be combined in a more elegant way, but it is only used to process a handful of files
     # at the beginning of a puppet run. TODO: Revisit for Puppet 4x when there is no 3x ast at the top.
+    # PUP-5299, some sites have thousands of entries, and run out of stack when evaluating - the logic
+    # below maps the logic as flatly as possible.
     #
     children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
-      memo << parsed_class.code
+      case parsed_class.code
+      when Puppet::Parser::AST::BlockExpression
+        # the BlockExpression wraps a single 4x instruction that is most likely wrapped in a Factory
+        memo += parsed_class.code.children.map {|c| c.is_a?(Puppet::Pops::Model::Factory) ? c.model : c }
+      when Puppet::Pops::Model::Factory
+        # If it is a 4x instruction wrapped in a Factory
+        memo += parsed_class.code.model
+      else
+        # It is the instruction directly
+        memo << parsed_class.code
+      end
     end
     Puppet::Parser::AST::BlockExpression.new(:children => children)
   end

data/lib/puppet/pops/parser/egrammar.ra

@@ -22,7 +22,8 @@ token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
 token FUNCTION
 token PRIVATE ATTR TYPE
 token FUNCTION
-token APPLICATION_R CONSUMES_R PRODUCES_R
+token APPLICATION_R CONSUMES_R PRODUCES_R SITE_R
+token APPLICATION PRODUCES CONSUMES SITE
 token LOW
 
 prechigh
@@ -193,8 +194,9 @@ resource
 #
 expression
   : primary_expression
+  | capability_mapping
   | call_function_expression
-  | expression LBRACK       expressions RBRACK =LBRACK { result = val[0][*val[2]]         ; loc result, val[0], val[3] }
+  | bracketed_expression
   | expression IN           expression                 { result = val[0].in val[2]        ; loc result, val[1] }
   | expression MATCH        expression                 { result = val[0] =~  val[2]       ; loc result, val[1] }
   | expression NOMATCH      expression                 { result = val[0].mne val[2]       ; loc result, val[1] }
@@ -219,6 +221,8 @@ expression
   | expression QMARK selector_entries                  { result = val[0].select(*val[2])  ; loc result, val[0] }
   |            LPAREN       assignment RPAREN          { result = val[1].paren()          ; loc result, val[0] }
 
+bracketed_expression
+  : expression LBRACK       expressions endcomma RBRACK =LBRACK { result = val[0][*val[2]]         ; loc result, val[0], val[4] }
 
 #---EXPRESSIONS
 #   (i.e. "argument list")
@@ -238,8 +242,12 @@ primary_expression
   | if_expression
   | unless_expression
   | definition_expression
+  # @todo lutter 2014-09-03: application declarations must be at the toplevel
+  # in a manifest - Should be validated, not handled here. helindbe 2015-09-10
+  | application_expression
   | hostclass_expression
   | node_definition_expression
+  | site_definition_expression
   | epp_render_expression
   | function_definition
   | reserved_word
@@ -459,7 +467,7 @@ attribute_operations
     | APPLICATION_R
     | CONSUMES_R
     | PRODUCES_R
-#    | BOOLEAN
+    | SITE_R
 
   # In this version, illegal combinations are validated instead of producing syntax errors
   # (Can give nicer error message "+> is not applicable to...")
@@ -492,6 +500,33 @@ definition_expression
       end
     }
 
+#---APPLICATION
+application_expression
+  : APPLICATION classname parameter_list LBRACE opt_statements RBRACE {
+    result = add_definition(Factory.APPLICATION(classname(val[1][:value]), val[2], val[4]))
+    loc result, val[0], val[5]
+  }
+
+capability_mapping
+  : classname capability_kw classname LBRACE  attribute_operations endcomma RBRACE {
+    result = Factory.CAPABILITY_MAPPING(val[1][:value],
+                                        Factory.QNAME(classname(val[0][:value])),
+                                        classname(val[2][:value]), val[4])
+    loc result, val[0], val[6]
+    add_mapping(result)
+  }
+  | bracketed_expression capability_kw classname LBRACE  attribute_operations endcomma RBRACE {
+    result = Factory.CAPABILITY_MAPPING(val[1][:value],
+                                        val[0],
+                                        classname(val[2][:value]), val[4])
+    loc result, val[0], val[6]
+    add_mapping(result)
+  }
+
+capability_kw
+  : PRODUCES
+  | CONSUMES
+
 #---HOSTCLASS
 #
 # Produces Model::HostClassDefinition
@@ -528,6 +563,20 @@ hostclass_expression
     : classname
     | DEFAULT
 
+#---SITE
+#
+# Produces Model::SiteDefinition
+#
+site_definition_expression
+  : SITE LBRACE statements RBRACE {
+    result = add_definition(Factory.SITE(val[2]))
+    loc result, val[0], val[3]
+    }
+  | SITE LBRACE RBRACE {
+    result = add_definition(Factory.SITE(nil))
+    loc result, val[0], val[2]
+    }
+
 #---NODE
 #
 # Produces Model::NodeDefinition
@@ -590,6 +639,7 @@ classname
   | APPLICATION_R
   | CONSUMES_R
   | PRODUCES_R
+  | SITE_R
   | CLASS { error val[0], "'class' is not a valid classname" }
 
 # Produces Array<Model::Parameter>
@@ -640,6 +690,7 @@ reserved_word
   | APPLICATION_R { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
   | CONSUMES_R    { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
   | PRODUCES_R    { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
+  | SITE_R        { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
 
 #---LITERALS (dynamic and static)
 #
@@ -744,6 +795,8 @@ keyword
   | ATTR
   | FUNCTION
   | PRIVATE
+  | APPLICATION
+  | PRODUCES
 
 nil
   : { result = nil}