puppet 3.7.3-x64-mingw32 → 3.7.4-x64-mingw32

data/lib/puppet/parser/relationship.rb

@@ -4,13 +4,28 @@ class Puppet::Parser::Relationship
   PARAM_MAP = {:relationship => :before, :subscription => :notify}
 
   def arrayify(resources)
-    case resources
-    when Puppet::Parser::Collector
-      resources.collected.values
-    when Array
-      resources
+    # This if statement is needed because the 3x parser cannot load
+    # Puppet::Pops. This logic can be removed for 4.0 when the 3x AST
+    # is removed (when Pops is always used).
+    if !(Puppet[:parser] == 'future')
+      case resources
+      when Puppet::Parser::Collector
+        resources.collected.values
+      when Array
+        resources
+      else
+        [resources]
+      end
     else
-      [resources]
+      require 'puppet/pops'
+      case resources
+      when Puppet::Pops::Evaluator::Collectors::AbstractCollector
+        resources.collected.values
+      when Array
+        resources
+      else
+        [resources]
+      end
     end
   end
 

data/lib/puppet/parser/resource.rb

@@ -189,15 +189,22 @@ class Puppet::Parser::Resource < Puppet::Resource
     copy_as_resource.to_ral
   end
 
-  # Is the receiver tagged with the given tags?
-  # This match takes into account the tags that a resource will inherit from its container
+  # Answers if this resource is tagged with at least one of the tags given in downcased string form.
+  #
+  # The method is a faster variant of the tagged? method that does no conversion of its
+  # arguments.
+  #
+  # The match takes into account the tags that a resource will inherit from its container
   # but have not been set yet.
   # It does *not* take tags set via resource defaults as these will *never* be set on
   # the resource itself since all resources always have tags that are automatically
   # assigned.
   #
-  def tagged?(*tags)
-    super || ((scope_resource = scope.resource) && scope_resource != self && scope_resource.tagged?(tags))
+  # @param tag_array [Array[String]] list tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
+  def raw_tagged?(tag_array)
+    super || ((scope_resource = scope.resource) && !scope_resource.equal?(self) && scope_resource.raw_tagged?(tag_array))
   end
 
   private

data/lib/puppet/pops.rb

@@ -100,6 +100,13 @@ module Puppet
       require 'puppet/pops/evaluator/evaluator_impl'
       require 'puppet/pops/evaluator/epp_evaluator'
       require 'puppet/pops/evaluator/callable_mismatch_describer'
+      require 'puppet/pops/evaluator/collector_transformer'
+      module Collectors
+        require 'puppet/pops/evaluator/collectors/abstract_collector'
+        require 'puppet/pops/evaluator/collectors/fixed_set_collector'
+        require 'puppet/pops/evaluator/collectors/catalog_collector'
+        require 'puppet/pops/evaluator/collectors/exported_collector'
+      end
     end
 
     # Subsystem for puppet functions defined in ruby.

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -330,11 +330,6 @@ class Puppet::Pops::Evaluator::AccessOperator
       end
     end
     case keys.size
-    when 1
-      result = Puppet::Pops::Types::PHashType.new()
-      result.key_type = o.key_type.copy
-      result.element_type = keys[0]
-      result
     when 2
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
@@ -354,7 +349,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
-        :base_type => 'Hash-Type', :min => 1, :max => 4, :actual => keys.size
+        :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
       })
     end
     result.size_type = size_t if size_t

data/lib/puppet/pops/evaluator/collector_transformer.rb

@@ -0,0 +1,219 @@
+class Puppet::Pops::Evaluator::CollectorTransformer
+
+  def initialize
+    @@query_visitor    ||= Puppet::Pops::Visitor.new(nil, "query", 1, 1)
+    @@match_visitor    ||= Puppet::Pops::Visitor.new(nil, "match", 1, 1)
+    @@evaluator        ||= Puppet::Pops::Evaluator::EvaluatorImpl.new
+    @@compare_operator ||= Puppet::Pops::Evaluator::CompareOperator.new()
+  end
+
+  def transform(o, scope)
+    raise ArgumentError, "Expected CollectExpression" unless o.is_a? Puppet::Pops::Model::CollectExpression
+
+    raise "LHS is not a type" unless o.type_expr.is_a? Puppet::Pops::Model::QualifiedReference
+    type = o.type_expr.value().downcase()
+
+    if type == 'class'
+      fail "Classes cannot be collected"
+    end
+
+    resource_type = scope.find_resource_type(type)
+    fail "Resource type #{type} doesn't exist" unless resource_type
+
+    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
+    line_num = adapter.line
+    position = adapter.pos
+    file_path = adapter.locator.file
+
+    if !o.operations.empty?
+      overrides = {
+        :parameters => o.operations.map{ |x| to_3x_param(x).evaluate(scope)},
+        :file       => file_path,
+        :line       => [line_num, position],
+        :source     => scope.source,
+        :scope      => scope
+      }
+    end
+
+    code = query_unless_nop(o.query, scope)
+
+    case o.query
+    when Puppet::Pops::Model::VirtualQuery
+      newcoll = Puppet::Pops::Evaluator::Collectors::CatalogCollector.new(scope, resource_type.name, code, overrides)
+    when Puppet::Pops::Model::ExportedQuery
+      match = match_unless_nop(o.query, scope)
+      newcoll = Puppet::Pops::Evaluator::Collectors::ExportedCollector.new(scope, resource_type.name, match, code, overrides)
+    end
+
+    scope.compiler.add_collection(newcoll)
+
+    newcoll
+  end
+
+protected
+
+  def query(o, scope)
+    @@query_visitor.visit_this_1(self, o, scope)
+  end
+
+  def match(o, scope)
+    @@match_visitor.visit_this_1(self, o, scope)
+  end
+
+  def query_unless_nop(query, scope)
+    unless query.expr.nil? || query.expr.is_a?(Puppet::Pops::Model::Nop)
+      query(query.expr, scope)
+    end
+  end
+
+  def match_unless_nop(query, scope)
+    unless query.expr.nil? || query.expr.is_a?(Puppet::Pops::Model::Nop)
+      match(query.expr, scope)
+    end
+  end
+
+  def query_AndExpression(o, scope)
+    left_code = query(o.left_expr, scope)
+    right_code = query(o.right_expr, scope)
+    proc do |resource|
+      left_code.call(resource) && right_code.call(resource)
+    end
+  end
+
+  def query_OrExpression(o, scope)
+    left_code = query(o.left_expr, scope)
+    right_code = query(o.right_expr, scope)
+    proc do |resource|
+      left_code.call(resource) || right_code.call(resource)
+    end
+  end
+
+  def query_ComparisonExpression(o, scope)
+    left_code = query(o.left_expr, scope)
+    right_code = query(o.right_expr, scope)
+
+    case o.operator
+    when :'=='
+      if left_code == "tag"
+        # Ensure that to_s and downcase is done once, i.e. outside the proc block and
+        # then use raw_tagged? instead of tagged?
+        if right_code.is_a?(Array)
+          tags = right_code
+        else
+          tags = [ right_code ]
+        end
+        tags = tags.collect do |t|
+          raise ArgumentError, 'Cannot transform a number to a tag' if t.is_a?(Numeric)
+          t.to_s.downcase
+        end
+        proc do |resource|
+          resource.raw_tagged?(tags)
+        end
+      else
+        proc do |resource|
+          if (tmp = resource[left_code]).is_a?(Array)
+            @@compare_operator.include?(tmp, right_code, scope)
+          else
+            @@compare_operator.equals(tmp, right_code)
+          end
+        end
+      end
+    when :'!='
+      proc do |resource|
+        !@@compare_operator.equals(resource[left_code], right_code)
+      end
+    end
+  end
+
+  def query_VariableExpression(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_LiteralBoolean(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_LiteralString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_ConcatenatedString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_LiteralNumber(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_QualifiedName(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_ParenthesizedExpression(o, scope)
+   query(o.expr, scope)
+  end
+
+  def query_Object(o, scope)
+    raise ArgumentError, "Cannot transform object of class #{o.class}"
+  end
+
+  def match_AndExpression(o, scope)
+    left_match = match(o.left_expr, scope)
+    right_match = match(o.right_expr, scope)
+    return [left_match, 'and', right_match]
+  end
+
+  def match_OrExpression(o, scope)
+    left_match = match(o.left_expr, scope)
+    right_match = match(o.right_expr, scope)
+    return [left_match, 'or', right_match]
+  end
+
+  def match_ComparisonExpression(o, scope)
+    left_match = match(o.left_expr, scope)
+    right_match = match(o.right_expr, scope)
+    return [left_match, o.operator.to_s, right_match]
+  end
+
+  def match_VariableExpression(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_LiteralBoolean(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_LiteralString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_ConcatenatedString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_LiteralNumber(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_QualifiedName(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_ParenthesizedExpression(o, scope)
+   match(o.expr, scope)
+  end
+
+  def match_Object(o, scope)
+    raise ArgumentError, "Cannot transform object of class #{o.class}"
+  end
+
+  # Produces (name => expr) or (name +> expr)
+  def to_3x_param(o)
+    bridge = Puppet::Parser::AST::PopsBridge::Expression.new(:value => o.value_expr)
+    args = { :value => bridge }
+    args[:add] = true if o.operator == :'+>'
+    args[:param] = o.attribute_name
+    args= Puppet::Pops::Model::AstTransformer.new().merge_location(args, o)
+    Puppet::Parser::AST::ResourceParam.new(args)
+  end
+end

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -0,0 +1,86 @@
+class Puppet::Pops::Evaluator::Collectors::AbstractCollector
+  attr_reader :scope
+
+  # The collector's hash of overrides {:parameters => params}
+  attr_reader :overrides
+
+  # The set of collected resources
+  attr_reader :collected
+
+  # An empty array which will be returned by the unresolved_resources
+  # method unless we have a FixSetCollector
+  EMPTY_RESOURCES = [].freeze
+
+  # Initialized the instance variables needed by the base
+  # collector class to perform evaluation
+  #
+  # @param [Puppet::Parser::Scope] scope
+  #
+  # @param [Hash] overrides a hash of optional overrides
+  # @options opts [Array] :parameters
+  # @options opts [String] :file
+  # @options opts [Array] :line
+  # @options opts [Puppet::Resource::Type] :source
+  # @options opts [Puppet::Parser::Scope] :scope
+  def initialize(scope, overrides = nil)
+    @collected = {}
+    @scope = scope
+
+    if !(overrides.nil? || overrides[:parameters])
+      raise ArgumentError, "Exported resource try to override without parameters"
+    end
+
+    @overrides = overrides
+  end
+
+  # Collects resources and marks collected objects as non-virtual. Also
+  # handles overrides.
+  #
+  # @return [Array] the resources we have collected
+  def evaluate
+    objects = collect.each do |obj|
+      obj.virtual = false
+    end
+
+    return false if objects.empty?
+
+    if @overrides and !objects.empty?
+      overrides[:source].meta_def(:child_of?) do |klass|
+        true
+      end
+
+      objects.each do |res|
+        unless @collected.include?(res.ref)
+          newres = Puppet::Parser::Resource.new(res.type, res.title, @overrides)
+          scope.compiler.add_override(newres)
+        end
+      end
+    end
+
+    objects.reject! { |o| @collected.include?(o.ref) }
+
+    return false if objects.empty?
+
+    objects.inject(@collected) { |c,o| c[o.ref]=o; c }
+
+    objects
+  end
+
+  # This should only return an empty array unless we have
+  # an FixedSetCollector, in which case it will return the
+  # resources that have not yet been realized
+  #
+  # @return [Array] the resources that have not been resolved
+  def unresolved_resources
+    EMPTY_RESOURCES
+  end
+
+  # Collect the specified resources. The way this is done depends on which type
+  # of collector we are dealing with. This method is implemented differently in
+  # each of the three child classes
+  #
+  # @return [Array] the collected resources
+  def collect
+    raise NotImplementedError, "This method must be implemented by the child class"
+  end
+end

data/lib/puppet/pops/evaluator/collectors/catalog_collector.rb

@@ -0,0 +1,25 @@
+class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+
+  # Creates a CatalogCollector using the AbstractCollector's 
+  # constructor to set the scope and overrides
+  #
+  # param [Symbol] type the resource type to be collected
+  # param [Proc] query the query which defines which resources to match
+  def initialize(scope, type, query, overrides = nil)
+    super(scope, overrides)
+
+    @query = query
+
+    @type = Puppet::Resource.new(type, "whatever").type
+  end
+
+  # Collects virtual resources based off a collection in a manifest
+  def collect
+    t = @type
+    q = @query
+
+    scope.compiler.resources.find_all do |resource|
+      resource.type == t && (q ?  q.call(resource) : true)
+    end
+  end
+end

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -0,0 +1,66 @@
+class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+
+  # Creates an ExportedCollector using the AbstractCollector's
+  # constructor to set the scope and overrides
+  #
+  # param [Symbol] type the resource type to be collected
+  # param [Array] equery an array representation of the query (exported query)
+  # param [Proc] cquery a proc representation of the query (catalog query)
+  def initialize(scope, type, equery, cquery, overrides = nil)
+    super(scope, overrides)
+
+    @equery = equery
+    @cquery = cquery
+
+    @type = Puppet::Resource.new(type, "whatever").type
+  end
+
+  # Ensures that storeconfigs is present before calling AbstractCollector's
+  # evaluate method
+  def evaluate
+    if Puppet[:storeconfigs] != true
+      Puppet.warning "Not collecting exported resources without storeconfigs"
+      return false
+    end
+
+    super
+  end
+
+  # Collect exported resources as defined by an exported
+  # collection. Used with PuppetDB
+  def collect
+    resources = []
+
+    time = Puppet::Util.thinmark do
+      t = @type
+      q = @cquery
+
+      resources = scope.compiler.resources.find_all do |resource|
+        resource.type == t && resource.exported? && (q.nil? || q.call(resource))
+      end
+
+      found = Puppet::Resource.indirection.
+        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)}
+
+      found_resources.each do |item|
+        if existing = @scope.findresource(item.type, item.title)
+          unless existing.collector_id == item.collector_id
+            raise Puppet::ParseError,
+              "A duplicate resource was found while collecting exported resources, with the type and title #{item.ref}"
+          end
+        else
+          item.exported = false
+          @scope.compiler.add_resource(@scope, item)
+          resources << item
+        end
+      end
+    end
+
+    scope.debug("Collected %s %s resource%s in %.2f seconds" %
+                [resources.length, @type, resources.length == 1 ? "" : "s", time])
+
+    resources
+  end
+end