openvox 7.37.1

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

@@ -0,0 +1,81 @@
+# The base class for all of the leaves of the parse trees.  These
+# basically just have types and values.  Both of these parameters
+# are simple values, not AST objects.
+#
+class Puppet::Parser::AST::Leaf < Puppet::Parser::AST
+  attr_accessor :value, :type
+  # Return our value.
+  def evaluate(scope)
+    @value
+  end
+
+  def match(value)
+    @value == value
+  end
+
+  def to_s
+    @value.to_s unless @value.nil?
+  end
+
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    @value = value
+    super(file: file, line: line, pos: pos)
+  end
+end
+
+# Host names, either fully qualified or just the short name, or even a regex
+#
+class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    super(value: value, file: file, line: line, pos: pos)
+
+    # Note that this is an AST::Regex, not a Regexp
+    unless @value.is_a?(Regex)
+      @value = @value.to_s.downcase
+      if @value =~ /[^-\w.]/
+        raise Puppet::DevError, _("'%{value}' is not a valid hostname") % { value: @value }
+      end
+    end
+  end
+
+  # implementing eql? and hash so that when an HostName is stored
+  # in a hash it has the same hashing properties as the underlying value
+  def eql?(value)
+    @value.eql?(value.is_a?(HostName) ? value.value : value)
+  end
+
+  def hash
+    @value.hash
+  end
+end
+
+class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    super(value: value, file: file, line: line, pos: pos)
+
+    # transform value from hash options unless it is already a regular expression
+    @value = Regexp.new(@value) unless @value.is_a?(Regexp)
+  end
+
+  # we're returning self here to wrap the regexp and to be used in places
+  # where a string would have been used, without modifying any client code.
+  # For instance, in many places we have the following code snippet:
+  #  val = @val.safeevaluate(@scope)
+  #  if val.match(otherval)
+  #      ...
+  #  end
+  # this way, we don't have to modify this test specifically for handling
+  # regexes.
+  #
+  def evaluate(scope)
+    self
+  end
+
+  def match(value)
+    @value.match(value)
+  end
+
+  def to_s
+    Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(@value)
+  end
+end

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

@@ -0,0 +1,17 @@
+class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :names, :context
+
+  def initialize(names, context = {})
+    raise ArgumentError, _("names should be an array") unless names.is_a? Array
+    if context[:parent]
+      raise Puppet::DevError, _("Node inheritance is removed in Puppet 4.0.0. See http://links.puppet.com/puppet-node-inheritance-deprecation")
+    end
+
+    @names = names
+    @context = context
+  end
+
+  def instantiate(modname)
+    @names.map { |name| Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname)) }
+  end
+end

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

@@ -0,0 +1,245 @@
+require_relative '../../../puppet/parser/ast/top_level_construct'
+require_relative '../../../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 to_s
+      Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
+    end
+
+    def source_text
+      source_adapter = Puppet::Pops::Utils.find_closest_positioned(@value)
+      source_adapter ? source_adapter.extract_text() : nil
+    end
+
+    def evaluate(scope)
+      evaluator = Puppet::Pops::Parser::EvaluatingParser.singleton
+      object = evaluator.evaluate(scope, @value)
+      evaluator.convert_to_3x(object, scope)
+    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
+
+  class ExpressionSupportingReturn < Expression
+    def evaluate(scope)
+      return catch(:return) do
+        return catch(:next) do
+          return super(scope)
+        end
+      end
+    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])
+    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.map 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
+          loaders = Puppet::Pops::Loaders.loaders
+          loaders.instantiate_definition(d, loaders.find_loader(modname))
+
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          nil
+        end
+      end.flatten().compact() # flatten since node definition may have returned an array
+                              # Compact since 4x definitions are not understood by compiler
+    end
+
+    def evaluate(scope)
+      Puppet::Pops::Parser::EvaluatingParser.singleton.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
+
+    # Returns true if this Program only contains definitions
+    def is_definitions_only?
+      is_definition?(program_model)
+    end
+
+    private
+
+    def is_definition?(o)
+      case o
+      when Puppet::Pops::Model::Program
+        is_definition?(o.body)
+      when Puppet::Pops::Model::BlockExpression
+        o.statements.all {|s| is_definition?(s) }
+      when Puppet::Pops::Model::Definition
+        true
+      else
+        false
+      end
+    end
+
+    def instantiate_Parameter(o)
+      # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
+      if o.value
+        [o.name, Expression.new(:value => o.value)]
+      else
+        [o.name]
+      end
+    end
+
+    def create_type_map(definition)
+      result = {}
+      # No need to do anything if there are no parameters
+      return result unless definition.parameters.size > 0
+
+      # No need to do anything if there are no typed parameters
+      typed_parameters = definition.parameters.select {|p| p.type_expr }
+      return result if typed_parameters.empty?
+
+      # If there are typed parameters, they need to be evaluated to produce the corresponding type
+      # instances. This evaluation requires a scope. A scope is not available when doing deserialization
+      # (there is also no initialized evaluator). When running apply and test however, the environment is
+      # reused and we may reenter without a scope (which is fine). A debug message is then output in case
+      # there is the need to track down the odd corner case. See {#obtain_scope}.
+      #
+      scope = obtain_scope
+      if scope
+        evaluator = Puppet::Pops::Parser::EvaluatingParser.singleton
+        typed_parameters.each do |p|
+          result[p.name] = evaluator.evaluate(scope, p.type_expr)
+        end
+      end
+      result
+    end
+
+    # Obtains the scope or issues a warning if :global_scope is not bound
+    def obtain_scope
+      scope = Puppet.lookup(:global_scope) do
+        # This occurs when testing and when applying a catalog (there is no scope available then), and
+        # when running tests that run a partial setup.
+        # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
+        # use case that there is no scope when requesting the type in order to just get the parameters.
+        Puppet.debug {_("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")}
+        nil
+      end
+      scope
+    end
+
+    # Produces a hash with data for Definition and HostClass
+    def args_from_definition(o, modname, expr_class = Expression)
+      args = {
+       :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
+       :argument_types => create_type_map(o),
+       :module_name => modname
+      }
+      unless is_nop?(o.body)
+        args[:code] = expr_class.new(:value => o.body)
+      end
+      @ast_transformer.merge_location(args, o)
+    end
+
+    def instantiate_HostClassDefinition(o, modname)
+      args = args_from_definition(o, modname, ExpressionSupportingReturn)
+      args[:parent] = absolute_reference(o.parent_class)
+      Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
+    end
+
+    def instantiate_ResourceTypeDefinition(o, modname)
+      instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname, ExpressionSupportingReturn)))
+      Puppet::Pops::Loaders.register_runtime3_type(instance.name, o.locator.to_uri(o))
+      instance
+    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
+      args = @ast_transformer.merge_location(args, o)
+
+      host_matches = @ast_transformer.hostname(o.host_matches)
+      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
+
+    def absolute_reference(ref)
+      if ref.nil? || ref.empty? || ref.start_with?('::')
+        ref
+      else
+        "::#{ref}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# Instruction for Resource instantiation.
+# Instantiates resources of both native and user defined types.
+#
+class Puppet::Parser::AST::Resource < Puppet::Parser::AST::Branch
+
+  attr_accessor :type, :instances, :exported, :virtual
+
+  def initialize(argshash)
+    Puppet.warn_once('deprecations', 'AST::Resource', _('Use of Puppet::Parser::AST::Resource is deprecated and not fully functional'))
+    super(argshash)
+  end
+
+  # Evaluates resources by adding them to the compiler for lazy evaluation
+  # and returning the produced resource references.
+  #
+  def evaluate(scope)
+    # We want virtual to be true if exported is true.  We can't
+    # just set :virtual => self.virtual in the initialization,
+    # because sometimes the :virtual attribute is set *after*
+    # :exported, in which case it clobbers :exported if :exported
+    # is true.  Argh, this was a very tough one to track down.
+    virt = self.virtual || self.exported
+
+    # First level of implicit iteration: build a resource for each
+    # instance.  This handles things like:
+    # file { '/foo': owner => blah; '/bar': owner => blah }
+    @instances.map do |instance|
+
+      # Evaluate all of the specified params.
+      paramobjects = instance.parameters.map { |param| param.safeevaluate(scope) }
+
+      resource_titles = instance.title.safeevaluate(scope)
+
+      # it's easier to always use an array, even for only one name
+      resource_titles = [resource_titles] unless resource_titles.is_a?(Array)
+
+      fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type, resource_titles)
+
+      # Second level of implicit iteration; build a resource for each
+      # title.  This handles things like:
+      # file { ['/foo', '/bar']: owner => blah }
+      resource_titles.flatten.map do |resource_title|
+        exceptwrap :type => Puppet::ParseError do
+          resource = Puppet::Parser::Resource.new(
+          fully_qualified_type, resource_title,
+            :parameters => paramobjects,
+            :file => self.file,
+            :line => self.line,
+            :exported => self.exported,
+            :virtual => virt,
+            :source => scope.source,
+            :scope => scope,
+            :strict => true
+          )
+
+          if resource.resource_type.is_a? Puppet::Resource::Type
+            resource.resource_type.instantiate_resource(scope, resource)
+          end
+          scope.compiler.add_resource(scope, resource)
+          scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == 'class'
+          resource
+        end
+      end
+    end.flatten.reject { |resource| resource.nil? }
+  end
+end

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

@@ -0,0 +1,10 @@
+# A simple container for a parameter for an object.  Consists of a
+# title and a set of parameters.
+#
+class Puppet::Parser::AST::ResourceInstance < Puppet::Parser::AST::Branch
+  attr_accessor :title, :parameters
+  def initialize(argshash)
+    Puppet.warn_once('deprecations', 'AST::ResourceInstance', _('Use of Puppet::Parser::AST::ResourceInstance is deprecated'))
+    super(argshash)
+  end
+end

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

@@ -0,0 +1,31 @@
+# The AST object for the parameters inside resource expressions
+#
+class Puppet::Parser::AST::ResourceParam < Puppet::Parser::AST::Branch
+  attr_accessor :value, :param, :add
+
+  def initialize(argshash)
+    Puppet.warn_once('deprecations', 'AST::ResourceParam', _('Use of Puppet::Parser::AST::ResourceParam is deprecated and not fully functional'))
+    super(argshash)
+  end
+
+  def each
+    [@param, @value].each { |child| yield child }
+  end
+
+  # Return the parameter and the value.
+  def evaluate(scope)
+    value = @value.safeevaluate(scope)
+    return Puppet::Parser::Resource::Param.new(
+      :name   => @param,
+      :value  => value.nil? ? :undef : value,
+      :source => scope.source, 
+      :line   => self.line,
+      :file   => self.file,
+      :add    => self.add
+    )
+  end
+
+  def to_s
+    "#{@param} => #{@value}"
+  end
+end

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

@@ -0,0 +1,4 @@
+# The base class for AST nodes representing top level things:
+# hostclasses, definitions, and nodes.
+class Puppet::Parser::AST::TopLevelConstruct < Puppet::Parser::AST
+end

data/lib/puppet/parser/ast.rb

@@ -0,0 +1,61 @@
+# The base class for the 3x "parse tree", now only used by the top level
+# constructs and the compiler.
+# Handles things like file name, line #, and also does the initialization
+# for all of the parameters of all of the child objects.
+#
+class Puppet::Parser::AST
+  AST = Puppet::Parser::AST
+
+  include Puppet::Util::Errors
+
+  attr_accessor :parent, :scope, :file, :line, :pos
+
+  def inspect
+    "( #{self.class} #{self} #{@children.inspect} )"
+  end
+
+  # Evaluate the current object.  Just a stub method, since the subclass
+  # should override this method.
+  def evaluate(scope)
+  end
+
+  # The version of the evaluate method that should be called, because it
+  # correctly handles errors.  It is critical to use this method because
+  # it can enable you to catch the error where it happens, rather than
+  # much higher up the stack.
+  def safeevaluate(scope)
+    # We duplicate code here, rather than using exceptwrap, because this
+    # is called so many times during parsing.
+    begin
+      return self.evaluate(scope)
+    rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+      raise detail
+#      # Only deals with StopIteration from the break() function as a general
+#      # StopIteration is a general runtime problem
+#      raise Puppet::ParseError.new(detail.message, detail.file, detail.line, detail)
+    rescue Puppet::Error => detail
+      raise adderrorcontext(detail)
+    rescue => detail
+      error = Puppet::ParseError.new(detail.to_s, nil, nil, detail)
+      # We can't use self.fail here because it always expects strings,
+      # not exceptions.
+      raise adderrorcontext(error, detail)
+    end
+  end
+
+  def initialize(file: nil, line: nil, pos: nil)
+    @file = file
+    @line = line
+    @pos = pos
+  end
+end
+
+# And include all of the AST subclasses.
+require_relative 'ast/branch'
+require_relative 'ast/leaf'
+require_relative 'ast/block_expression'
+require_relative 'ast/hostclass'
+require_relative 'ast/node'
+require_relative 'ast/resource'
+require_relative 'ast/resource_instance'
+require_relative 'ast/resourceparam'

data/lib/puppet/parser/catalog_compiler.rb

@@ -0,0 +1,56 @@
+require_relative '../../puppet/loaders'
+require_relative '../../puppet/pops'
+
+# A Catalog "compiler" that is like the regular compiler but with an API
+# that is harmonized with the ScriptCompiler
+#
+# The Script compiler is "one shot" - it does not support rechecking if underlying source has changed or
+# deal with possible errors in a cached environment.
+#
+class Puppet::Parser::CatalogCompiler < Puppet::Parser::Compiler
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    Puppet.override(rich_data: true) do
+      super
+    end
+
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node.name
+    Puppet.log_exception(detail)
+    raise
+  rescue => detail
+    message = "#{detail} on node #{node.name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
+  end
+
+  # Evaluates all added constructs, and validates the resulting catalog.
+  # This can be called whenever a series of evaluation of puppet code strings
+  # have reached a stable state (essentially that there are no relationships to
+  # non-existing resources).
+  #
+  # Raises an error if validation fails.
+  #
+  def compile_additions
+    evaluate_additions
+    validate
+  end
+
+  # Evaluates added constructs that are lazily evaluated until all of them have been evaluated.
+  # 
+  def evaluate_additions
+    evaluate_generators
+    finish
+  end
+
+  # Validates the current state of the catalog.
+  # Does not cause evaluation of lazy constructs.
+  def validate
+    validate_catalog(CatalogValidator::FINAL)
+  end
+end

data/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -0,0 +1,39 @@
+class Puppet::Parser::Compiler
+  # Validator that asserts relationship metaparameters refer to valid resources
+  class CatalogValidator::RelationshipValidator < CatalogValidator
+    def validate
+      catalog.resources.each do |resource|
+        next unless resource.is_a?(Puppet::Parser::Resource)
+        next if resource.virtual?
+        resource.eachparam do |param|
+          pclass = Puppet::Type.metaparamclass(param.name)
+          validate_relationship(param) if !pclass.nil? && pclass < Puppet::Type::RelationshipMetaparam
+        end
+      end
+      nil
+    end
+
+    private
+
+    def validate_relationship(param)
+      # the referenced resource must exist
+      refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
+      refs.each do |r|
+        next if r.nil? || r == :undef
+        res = r.to_s
+        begin
+          found = catalog.resource(res)
+        rescue ArgumentError => e
+          # Raise again but with file and line information
+          raise CatalogValidationError.new(e.message, param.file, param.line)
+        end
+        unless found
+          msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: res, param: param.name.to_s }
+          raise CatalogValidationError.new(msg, param.file, param.line)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/puppet/parser/compiler/catalog_validator.rb

@@ -0,0 +1,33 @@
+# Abstract class for a catalog validator that can be registered with the compiler to run at
+# a certain stage.
+class Puppet::Parser::Compiler
+  class CatalogValidator
+    PRE_FINISH = :pre_finish
+    FINAL = :final
+
+    # Returns true if the validator should run at the given stage. The default
+    # implementation will only run at stage `FINAL`
+    #
+    # @param stage [Symbol] One of the stage constants defined in this class
+    # @return [Boolean] true if the validator should run at the given stage
+    #
+    def self.validation_stage?(stage)
+      FINAL.equal?(stage)
+    end
+
+    attr_reader :catalog
+
+    # @param catalog [Puppet::Resource::Catalog] The catalog to validate
+    def initialize(catalog)
+      @catalog = catalog
+    end
+
+    # Validate some aspect of the catalog and raise a `CatalogValidationError` on failure
+    def validate
+    end
+  end
+
+  class CatalogValidationError < Puppet::Error
+    include Puppet::ExternalFileError
+  end
+end