openvox 7.37.1

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].override = true
+
+      objects.each do |res|
+        unless @collected.include?(res.ref)
+          t = res.type
+          t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t)
+          newres = Puppet::Parser::Resource.new(t, res.title, @overrides)
+          scope.compiler.add_override(newres)
+        end
+      end
+    end
+
+    objects.reject! { |o| @collected.include?(o.ref) }
+
+    return false if objects.empty?
+
+    objects.reduce(@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,29 @@
+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 [Puppet::CompilableResourceType] 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
+
+  def to_s
+    "Catalog-Collector[#{@type}]"
+  end
+end

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

@@ -0,0 +1,70 @@
+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 [Puppet::CompilableResourceType] 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
+      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|
+        existing = @scope.findresource(item.resource_type, item.title)
+        if existing
+          unless existing.collector_id == item.collector_id
+            raise Puppet::ParseError,
+              _("A duplicate resource was found while collecting exported resources, with the type and title %{title}") % { 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
+
+  def to_s
+    "Exported-Collector[#{@type}]"
+  end
+end

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

@@ -0,0 +1,38 @@
+class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+
+  # Creates a FixedSetCollector using the AbstractCollector constructor
+  # to set the scope. It is not possible for a collection to have
+  # overrides in this case, since we have a fixed set of resources that
+  # can be different types.
+  #
+  # @param [Array] resources the fixed set of resources we want to realize
+  def initialize(scope, resources)
+    super(scope)
+    @resources = resources.is_a?(Array)? resources.dup : [resources]
+  end
+
+  # Collects a fixed set of resources and realizes them. Used
+  # by the realize function
+  def collect
+    resolved = []
+    result = @resources.reduce([]) do |memo, ref|
+      res = @scope.findresource(ref.to_s)
+      if res
+        res.virtual = false
+        memo << res
+        resolved << ref
+      end
+      memo
+    end
+
+    @resources = @resources - resolved
+
+    @scope.compiler.delete_collection(self) if @resources.empty?
+
+    result
+  end
+
+  def unresolved_resources
+    @resources
+  end
+end

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

@@ -0,0 +1,254 @@
+module Puppet::Pops
+module Evaluator
+# Compares the puppet DSL way
+#
+# ==Equality
+# All string vs. numeric equalities check for numeric equality first, then string equality
+# Arrays are equal to arrays if they have the same length, and each element #equals
+# Hashes  are equal to hashes if they have the same size and keys and values #equals.
+# All other objects are equal if they are ruby #== equal
+#
+class CompareOperator
+  include Utils
+
+  # Provides access to the Puppet 3.x runtime (scope, etc.)
+  # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
+  #
+  include Runtime3Support
+
+  def initialize
+    @@equals_visitor  ||= Visitor.new(self, "equals", 1, 1)
+    @@compare_visitor ||= Visitor.new(self, "cmp", 1, 1)
+    @@match_visitor ||= Visitor.new(self, "match", 2, 2)
+    @@include_visitor ||= Visitor.new(self, "include", 2, 2)
+  end
+
+  def equals(a, b)
+    @@equals_visitor.visit_this_1(self, a, b)
+  end
+
+  # Performs a comparison of a and b, and return > 0 if a is bigger, 0 if equal, and < 0 if b is bigger.
+  # Comparison of String vs. Numeric always compares using numeric.
+  def compare(a, b)
+    @@compare_visitor.visit_this_1(self, a, b)
+  end
+
+  # Performs a match of a and b, and returns true if b matches a
+  def match(a, b, scope = nil)
+    @@match_visitor.visit_this_2(self, b, a, scope)
+  end
+
+  # Answers is b included in a
+  def include?(a, b, scope)
+    @@include_visitor.visit_this_2(self, a, b, scope)
+  end
+
+  protected
+
+  def cmp_String(a, b)
+    return a.casecmp(b) if b.is_a?(String)
+    raise ArgumentError.new(_("A String is not comparable to a non String"))
+  end
+
+  # Equality is case independent.
+  def equals_String(a, b)
+    return false unless b.is_a?(String)
+    a.casecmp(b) == 0
+  end
+
+  def cmp_Numeric(a, b)
+    if b.is_a?(Numeric)
+      a <=> b
+    elsif b.is_a?(Time::Timespan) || b.is_a?(Time::Timestamp)
+      -(b <=> a) # compare other way and invert result
+    else
+      raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
+    end
+  end
+
+  def equals_Numeric(a, b)
+    if b.is_a?(Numeric)
+      a == b
+    else
+      false
+    end
+  end
+
+  def equals_Array(a, b)
+    return false unless b.is_a?(Array) && a.size == b.size
+    a.each_index {|i| return false unless equals(a.slice(i), b.slice(i)) }
+    true
+  end
+
+  def equals_Hash(a, b)
+    return false unless b.is_a?(Hash) && a.size == b.size
+    a.each {|ak, av| return false unless equals(b[ak], av)}
+    true
+  end
+
+  def cmp_Symbol(a, b)
+    if b.is_a?(Symbol)
+      a <=> b
+    else
+      raise ArgumentError.new(_("Symbol not comparable to non Symbol"))
+    end
+  end
+
+  def cmp_Timespan(a, b)
+    raise ArgumentError.new(_('Timespans are only comparable to Timespans, Integers, and Floats')) unless b.is_a?(Time::Timespan) ||  b.is_a?(Integer) || b.is_a?(Float)
+    a <=> b
+  end
+
+  def cmp_Timestamp(a, b)
+    raise ArgumentError.new(_('Timestamps are only comparable to Timestamps, Integers, and Floats')) unless b.is_a?(Time::Timestamp) ||  b.is_a?(Integer) || b.is_a?(Float)
+    a <=> b
+  end
+
+  def cmp_Version(a, b)
+    raise ArgumentError.new(_('Versions not comparable to non Versions')) unless b.is_a?(SemanticPuppet::Version)
+    a <=> b
+  end
+
+  def cmp_Object(a, b)
+    raise ArgumentError.new(_('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable'))
+  end
+
+
+  def equals_Object(a, b)
+    a == b
+  end
+
+  def equals_NilClass(a, b)
+    # :undef supported in case it is passed from a 3x data structure
+    b.nil? || b == :undef
+  end
+
+  def equals_Symbol(a, b)
+    # :undef supported in case it is passed from a 3x data structure
+    a == b || a == :undef && b.nil?
+  end
+
+  def include_Object(a, b, scope)
+    false
+  end
+
+  def include_String(a, b, scope)
+    case b
+    when String
+      # substring search downcased
+      a.downcase.include?(b.downcase)
+    when Regexp
+      matched = a.match(b)           # nil, or MatchData
+      set_match_data(matched, scope) # creates ephemeral
+      !!matched                      # match (convert to boolean)
+    when Numeric
+      # convert string to number, true if ==
+      equals(a, b)
+    else
+      false
+    end
+  end
+
+  def include_Binary(a, b, scope)
+    case b
+    when Puppet::Pops::Types::PBinaryType::Binary
+      a.binary_buffer.include?(b.binary_buffer)
+    when String
+      a.binary_buffer.include?(b)
+    when Numeric
+      a.binary_buffer.bytes.include?(b)
+    else
+      false
+    end
+  end
+
+  def include_Array(a, b, scope)
+    case b
+    when Regexp
+      matched = nil
+      a.each do |element|
+        next unless element.is_a? String
+        matched = element.match(b) # nil, or MatchData
+        break if matched
+      end
+      # Always set match data, a "not found" should not keep old match data visible
+      set_match_data(matched, scope) # creates ephemeral
+      return !!matched
+    when String, SemanticPuppet::Version
+      a.any? { |element| match(b, element, scope) }
+    when Types::PAnyType
+      a.each {|element| return true if b.instance?(element) }
+      return false
+    else
+      a.each {|element| return true if equals(element, b) }
+      return false
+    end
+  end
+
+  def include_Hash(a, b, scope)
+    include?(a.keys, b, scope)
+  end
+
+  def include_VersionRange(a, b, scope)
+    Types::PSemVerRangeType.include?(a, b)
+  end
+
+  # Matches in general by using == operator
+  def match_Object(pattern, a, scope)
+    equals(a, pattern)
+  end
+
+  # Matches only against strings
+  def match_Regexp(regexp, left, scope)
+    return false unless left.is_a? String
+    matched = regexp.match(left)
+    set_match_data(matched, scope) unless scope.nil? # creates or clears ephemeral
+    !!matched # convert to boolean
+  end
+
+  # Matches against semvers and strings
+  def match_Version(version, left, scope)
+    if left.is_a?(SemanticPuppet::Version)
+      version == left
+    elsif left.is_a? String
+      begin
+        version == SemanticPuppet::Version.parse(left)
+      rescue ArgumentError
+        false
+      end
+    else
+      false
+    end
+  end
+
+  # Matches against semvers and strings
+  def match_VersionRange(range, left, scope)
+    Types::PSemVerRangeType.include?(range, left)
+  end
+
+  def match_PAnyType(any_type, left, scope)
+    # right is a type and left is not - check if left is an instance of the given type
+    # (The reverse is not terribly meaningful - computing which of the case options that first produces
+    # an instance of a given type).
+    #
+    any_type.instance?(left)
+  end
+
+  def match_Array(array, left, scope)
+    return false unless left.is_a?(Array)
+    return false unless left.length == array.length
+    array.each_with_index.all? { | pattern, index| match(left[index], pattern, scope) }
+  end
+
+  def match_Hash(hash, left, scope)
+    return false unless left.is_a?(Hash)
+    hash.all? {|x,y| match(left[x], y, scope) }
+  end
+
+  def match_Symbol(symbol, left, scope)
+    return true if symbol == :default
+    equals(left, default)
+  end
+end
+end
+end

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

@@ -0,0 +1,225 @@
+require_relative '../../../puppet/parser/script_compiler'
+
+module Puppet::Pops
+module Evaluator
+
+class DeferredValue
+  def initialize(proc)
+    @proc = proc
+  end
+
+  def resolve
+    val = @proc.call
+    # Deferred sensitive values will be marked as such in resolve_futures()
+    if val.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      val.unwrap
+    else
+      val
+    end
+  end
+end
+
+# Utility class to help resolve instances of Puppet::Pops::Types::PDeferredType::Deferred
+#
+class DeferredResolver
+  DOLLAR = '$'.freeze
+  DIG    = 'dig'.freeze
+
+  # Resolves and replaces all Deferred values in a catalog's resource attributes
+  # found as direct values or nested inside Array, Hash or Sensitive values.
+  # Deferred values inside of custom Object instances are not resolved as this
+  # is expected to be done by such objects.
+  #
+  # @param facts [Puppet::Node::Facts] the facts object for the node
+  # @param catalog [Puppet::Resource::Catalog] the catalog where all deferred values should be replaced
+  # @param environment [Puppet::Node::Environment] the environment whose anonymous module methods
+  #  are to be mixed into the scope
+  # @return [nil] does not return anything - the catalog is modified as a side effect
+  #
+  def self.resolve_and_replace(facts, catalog, environment = catalog.environment_instance, preprocess_deferred = true)
+    compiler = Puppet::Parser::ScriptCompiler.new(environment, catalog.name, preprocess_deferred)
+    resolver = new(compiler, preprocess_deferred)
+    resolver.set_facts_variable(facts)
+    # TODO:
+    #    # When scripting the trusted data are always local, but set them anyway
+    #    @scope.set_trusted(node.trusted_data)
+    #
+    #    # Server facts are always about the local node's version etc.
+    #    @scope.set_server_facts(node.server_facts)
+
+    resolver.resolve_futures(catalog)
+    nil
+  end
+
+  # Resolves a value such that a direct Deferred, or any nested Deferred values
+  # are resolved and used instead of the deferred value.
+  # A direct Deferred value, or nested deferred values inside of Array, Hash or
+  # Sensitive values are resolved and replaced inside of freshly created
+  # containers.
+  #
+  # The resolution takes place in the topscope of the given compiler.
+  # Variable values are supposed to already have been set.
+  #
+  # @param value [Object] the (possibly nested) value to resolve
+  # @param compiler [Puppet::Parser::ScriptCompiler, Puppet::Parser::Compiler] the compiler in effect
+  # @return [Object] the resolved value (a new Array, Hash, or Sensitive if needed), with all deferred values resolved
+  #
+  def self.resolve(value, compiler)
+    resolver = new(compiler)
+    resolver.resolve(value)
+  end
+
+  def initialize(compiler, preprocess_deferred = true)
+    @compiler = compiler
+    # Always resolve in top scope
+    @scope = @compiler.topscope
+    @deferred_class = Puppet::Pops::Types::TypeFactory.deferred.implementation_class
+    @preprocess_deferred = preprocess_deferred
+  end
+
+  # @param facts [Puppet::Node::Facts] the facts to set in $facts in the compiler's topscope
+  #
+  def set_facts_variable(facts)
+    @scope.set_facts(facts.nil? ? {} : facts.values)
+  end
+
+  def resolve_futures(catalog)
+    catalog.resources.each do |r|
+      overrides = {}
+      r.parameters.each_pair do |k, v|
+        resolved = resolve(v)
+        case resolved
+        when Puppet::Pops::Types::PSensitiveType::Sensitive
+          # If the resolved value is instance of Sensitive - assign the unwrapped value
+          # and mark it as sensitive if not already marked
+          #
+          resolved = resolved.unwrap
+          mark_sensitive_parameters(r, k)
+
+        when Puppet::Pops::Evaluator::DeferredValue
+          # If the resolved value is a DeferredValue and it has an argument of type
+          # PSensitiveType, mark it as sensitive. Since DeferredValues can nest,
+          # we must walk all arguments, e.g. the DeferredValue may call the `epp`
+          # function, where one of its arguments is a DeferredValue to call the
+          # `vault:lookup` function.
+          #
+          # The DeferredValue.resolve method will unwrap the sensitive during
+          # catalog application
+          #
+          if contains_sensitive_args?(v)
+            mark_sensitive_parameters(r, k)
+          end
+        end
+        overrides[ k ] = resolved
+      end
+      r.parameters.merge!(overrides) unless overrides.empty?
+    end
+  end
+
+  # Return true if x contains an argument that is an instance of PSensitiveType:
+  #
+  #   Deferred('new', [Sensitive, 'password'])
+  #
+  # Or an instance of PSensitiveType::Sensitive:
+  #
+  #   Deferred('join', [['a', Sensitive('b')], ':'])
+  #
+  # Since deferred values can nest, descend into Arrays and Hash keys and values,
+  # short-circuiting when the first occurrence is found.
+  #
+  def contains_sensitive_args?(x)
+    case x
+    when @deferred_class
+      contains_sensitive_args?(x.arguments)
+    when Array
+      x.any? { |v| contains_sensitive_args?(v) }
+    when Hash
+      x.any? { |k, v| contains_sensitive_args?(k) || contains_sensitive_args?(v) }
+    when Puppet::Pops::Types::PSensitiveType, Puppet::Pops::Types::PSensitiveType::Sensitive
+      true
+    else
+      false
+    end
+  end
+  private :contains_sensitive_args?
+
+  def mark_sensitive_parameters(r, k)
+    unless r.sensitive_parameters.include?(k.to_sym)
+      r.sensitive_parameters = (r.sensitive_parameters + [k.to_sym]).freeze
+    end
+  end
+  private :mark_sensitive_parameters
+
+  def resolve(x)
+    if x.class == @deferred_class
+      resolve_future(x)
+    elsif x.is_a?(Array)
+      x.map {|v| resolve(v) }
+    elsif x.is_a?(Hash)
+      result = {}
+      x.each_pair {|k,v| result[k] = resolve(v) }
+      result
+    elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      # rewrap in a new Sensitive after resolving any nested deferred values
+      Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve(x.unwrap))
+    elsif x.is_a?(Puppet::Pops::Types::PBinaryType::Binary)
+      # use the ASCII-8BIT string that it wraps
+      x.binary_buffer
+    else
+      x
+    end
+  end
+
+  def resolve_lazy_args(x)
+    if x.is_a?(DeferredValue)
+      x.resolve
+    elsif x.is_a?(Array)
+      x.map {|v| resolve_lazy_args(v) }
+    elsif x.is_a?(Hash)
+      result = {}
+      x.each_pair {|k,v| result[k] = resolve_lazy_args(v) }
+      result
+    elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      # rewrap in a new Sensitive after resolving any nested deferred values
+      Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve_lazy_args(x.unwrap))
+    else
+      x
+    end
+  end
+  private :resolve_lazy_args
+
+  def resolve_future(f)
+    # If any of the arguments to a future is a future it needs to be resolved first
+    func_name = f.name
+    mapped_arguments = map_arguments(f.arguments)
+    # if name starts with $ then this is a call to dig
+    if func_name[0] == DOLLAR
+      var_name = func_name[1..-1]
+      func_name = DIG
+      mapped_arguments.insert(0, @scope[var_name])
+    end
+
+    if @preprocess_deferred
+      # call the function (name in deferred, or 'dig' for a variable)
+      @scope.call_function(func_name, mapped_arguments)
+    else
+      # call the function later
+      DeferredValue.new(
+        Proc.new {
+          # deferred functions can have nested deferred arguments
+          resolved_arguments = mapped_arguments.map { |arg| resolve_lazy_args(arg) }
+          @scope.call_function(func_name, resolved_arguments)
+        }
+      )
+    end
+  end
+
+  def map_arguments(args)
+    return [] if args.nil?
+    args.map {|v| resolve(v) }
+  end
+  private :map_arguments
+
+end
+end
+end