openvox 8.19.0

data/lib/puppet/parser/script_compiler.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/loaders'
+require_relative '../../puppet/pops'
+
+# A Script "compiler" that does not support catalog operations
+#
+# 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::ScriptCompiler
+  # Allows the ScriptCompiler to use the 3.x Scope class without being an actual "Compiler"
+  #
+  include Puppet::Parser::AbstractCompiler
+
+  # @api private
+  attr_reader :topscope
+
+  # @api private
+  attr_reader :qualified_variables
+
+  # Access to the configured loaders for 4x
+  # @return [Puppet::Pops::Loader::Loaders] the configured loaders
+  # @api private
+  attr_reader :loaders
+
+  # @api private
+  attr_reader :environment
+
+  # @api private
+  attr_reader :node_name
+
+  def with_context_overrides(description = '', &block)
+    Puppet.override(@context_overrides, description, &block)
+  end
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    # TRANSLATORS, "For running script" is not user facing
+    Puppet.override(@context_overrides, "For running script") do
+      # TRANSLATORS "main" is a function name and should not be translated
+      result = Puppet::Util::Profiler.profile(_("Script: Evaluated main"), [:script, :evaluate_main]) { evaluate_main }
+      if block_given?
+        yield self
+      else
+        result
+      end
+    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
+
+  # Constructs the overrides for the context
+  def context_overrides
+    {
+      :current_environment => environment,
+      :global_scope => @topscope, # 4x placeholder for new global scope
+      :loaders => @loaders, # 4x loaders
+      :rich_data => true,
+    }
+  end
+
+  # Create a script compiler for the given environment where errors are logged as coming
+  # from the given node_name
+  #
+  def initialize(environment, node_name, for_agent = false)
+    @environment = environment
+    @node_name = node_name
+
+    # Create the initial scope, it is needed early
+    @topscope = Puppet::Parser::Scope.new(self)
+
+    # Initialize loaders and Pcore
+    if for_agent
+      @loaders = Puppet::Pops::Loaders.new(environment, true)
+    else
+      @loaders = Puppet::Pops::Loaders.new(environment)
+    end
+
+    # Need to compute overrides here, and remember them, because we are about to
+    # Expensive entries in the context are bound lazily.
+    @context_overrides = context_overrides()
+
+    # Resolutions of fully qualified variable names
+    @qualified_variables = {}
+  end
+
+  # Having multiple named scopes hanging from top scope is not supported when scripting
+  # in the regular compiler this is used to create one named scope per class.
+  # When scripting, the "main class" is just a container of the top level code to evaluate
+  # and it is not evaluated as a class added to a catalog. Since classes are not supported
+  # there is no need to support the concept of "named scopes" as all variables are local
+  # or in the top scope itself (notably, the $settings:: namespace is initialized
+  # as just a set of variables in that namespace - there is no named scope for 'settings'
+  # when scripting.
+  #
+  # Keeping this method here to get specific error as being unsure if there are functions/logic
+  # that will call this. The AbstractCompiler defines this method, but maybe it does not
+  # have to (TODO).
+  #
+  def newscope(parent, options = {})
+    raise _('having multiple named scopes is not supported when scripting')
+  end
+
+  private
+
+  # Find and evaluate the top level code.
+  def evaluate_main
+    @loaders.pre_load
+    program = @loaders.load_main_manifest
+    program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
+  end
+end

data/lib/puppet/parser/templatewrapper.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/parser/files'
+require 'erb'
+require_relative '../../puppet/file_system'
+
+# A simple wrapper for templates, so they don't have full access to
+# the scope objects.
+#
+# @api private
+class Puppet::Parser::TemplateWrapper
+  include Puppet::Util
+  Puppet::Util.logmethods(self)
+
+  def initialize(scope)
+    @__scope__ = scope
+  end
+
+  # @return [String] The full path name of the template that is being executed
+  # @api public
+  def file
+    @__file__
+  end
+
+  # @return [Puppet::Parser::Scope] The scope in which the template is evaluated
+  # @api public
+  def scope
+    @__scope__
+  end
+
+  # Find which line in the template (if any) we were called from.
+  # @return [String] the line number
+  # @api private
+  def script_line
+    identifier = Regexp.escape(@__file__ || "(erb)")
+    (caller.find { |l| l =~ /#{identifier}:/ } || "")[/:(\d+):/, 1]
+  end
+  private :script_line
+
+  # Should return true if a variable is defined, false if it is not
+  # @api public
+  def has_variable?(name)
+    scope.include?(name.to_s)
+  end
+
+  # @return [Array<String>] The list of defined classes
+  # @api public
+  def classes
+    scope.catalog.classes
+  end
+
+  # @return [Array<String>] The tags defined in the current scope
+  # @api public
+  def tags
+    raise NotImplementedError, "Call 'all_tags' instead."
+  end
+
+  # @return [Array<String>] All the defined tags
+  # @api public
+  def all_tags
+    scope.catalog.tags
+  end
+
+  # @api private
+  def file=(filename)
+    @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
+    unless @__file__
+      raise Puppet::ParseError, _("Could not find template '%{filename}'") % { filename: filename }
+    end
+  end
+
+  # @api private
+  def result(string = nil)
+    if string
+      template_source = "inline template"
+    else
+      string = Puppet::FileSystem.read_preserve_line_endings(@__file__)
+      template_source = @__file__
+    end
+
+    # Expose all the variables in our scope as instance variables of the
+    # current object, making it possible to access them without conflict
+    # to the regular methods.
+    escaped_template_source = template_source.gsub(/%/, '%%')
+    benchmark(:debug, _("Bound template variables for %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
+      scope.to_hash.each do |name, value|
+        realname = name.gsub(/[^\w]/, "_")
+        instance_variable_set("@#{realname}", value)
+      end
+    end
+
+    result = nil
+    benchmark(:debug, _("Interpolated template %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
+      template = Puppet::Util.create_erb(string)
+      template.filename = @__file__
+      result = template.result(binding)
+    end
+
+    result
+  end
+
+  def to_s
+    "template[#{@__file__ || 'inline'}]"
+  end
+end

data/lib/puppet/parser/type_loader.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'find'
+require 'forwardable'
+require_relative '../../puppet/parser/parser_factory'
+
+class Puppet::Parser::TypeLoader
+  extend Forwardable
+
+  class TypeLoaderError < StandardError; end
+
+  # Import manifest files that match a given file glob pattern.
+  #
+  # @param pattern [String] the file glob to apply when determining which files
+  #   to load
+  # @param dir [String] base directory to use when the file is not
+  #   found in a module
+  # @api private
+  def import(pattern, dir)
+    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
+    if files.empty?
+      abspat = File.expand_path(pattern, dir)
+      file_pattern = abspat + (File.extname(abspat).empty? ? '.pp' : '')
+
+      files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
+      modname = nil
+
+      if files.empty?
+        raise_no_files_found(pattern)
+      end
+    end
+
+    load_files(modname, files)
+  end
+
+  # Load all of the manifest files in all known modules.
+  # @api private
+  def import_all
+    # And then load all files from each module, but (relying on system
+    # behavior) only load files from the first module of a given name.  E.g.,
+    # given first/foo and second/foo, only files from first/foo will be loaded.
+    environment.modules.each do |mod|
+      load_files(mod.name, mod.all_manifests)
+    end
+  end
+
+  def_delegator :environment, :known_resource_types
+
+  def initialize(env)
+    self.environment = env
+  end
+
+  def environment
+    @environment
+  end
+
+  def environment=(env)
+    if env.is_a?(String) or env.is_a?(Symbol)
+      @environment = Puppet.lookup(:environments).get!(env)
+    else
+      @environment = env
+    end
+  end
+
+  # Try to load the object with the given fully qualified name.
+  def try_load_fqname(type, fqname)
+    return nil if fqname == "" # special-case main.
+
+    files_to_try_for(fqname).each do |filename|
+      imported_types = import_from_modules(filename)
+      result = imported_types.find { |t| t.type == type and t.name == fqname }
+      if result
+        Puppet.debug { "Automatically imported #{fqname} from #{filename} into #{environment}" }
+        return result
+      end
+    rescue TypeLoaderError
+      # I'm not convinced we should just drop these errors, but this
+      # preserves existing behaviours.
+    end
+    # Nothing found.
+    nil
+  end
+
+  def parse_file(file)
+    Puppet.debug { "importing '#{file}' in environment #{environment}" }
+    parser = Puppet::Parser::ParserFactory.parser
+    parser.file = file
+    parser.parse
+  end
+
+  private
+
+  def import_from_modules(pattern)
+    modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
+    if files.empty?
+      raise_no_files_found(pattern)
+    end
+
+    load_files(modname, files)
+  end
+
+  def raise_no_files_found(pattern)
+    raise TypeLoaderError, _("No file(s) found for import of '%{pattern}'") % { pattern: pattern }
+  end
+
+  def load_files(modname, files)
+    @loaded ||= {}
+    loaded_asts = []
+    files.reject { |file| @loaded[file] }.each do |file|
+      # The squelch_parse_errors use case is for parsing for the purpose of searching
+      # for information and it should not abort.
+      # There is currently one user in indirector/resourcetype/parser
+      #
+      if Puppet.lookup(:squelch_parse_errors) { false }
+        begin
+          loaded_asts << parse_file(file)
+        rescue => e
+          # Resume from errors so that all parseable files may
+          # still be parsed. Mark this file as loaded so that
+          # it would not be parsed next time (handle it as if
+          # it was successfully parsed).
+          Puppet.debug { "Unable to parse '#{file}': #{e.message}" }
+        end
+      else
+        loaded_asts << parse_file(file)
+      end
+
+      @loaded[file] = true
+    end
+
+    loaded_asts.collect do |ast|
+      known_resource_types.import_ast(ast, modname)
+    end.flatten
+  end
+
+  # Return a list of all file basenames that should be tried in order
+  # to load the object with the given fully qualified name.
+  def files_to_try_for(qualified_name)
+    qualified_name.split('::').inject([]) do |paths, name|
+      add_path_for_name(paths, name)
+    end
+  end
+
+  def add_path_for_name(paths, name)
+    if paths.empty?
+      [name]
+    else
+      paths.unshift(File.join(paths.first, name))
+    end
+  end
+end

data/lib/puppet/parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# is only needed to create the name space
+module Puppet::Parser; end
+
+require_relative 'parser/ast'
+require_relative 'parser/abstract_compiler'
+require_relative 'parser/compiler'
+require_relative 'parser/compiler/catalog_validator'
+require_relative '../puppet/resource/type_collection'
+
+require_relative 'parser/functions'
+require_relative 'parser/files'
+require_relative 'parser/relationship'
+
+require_relative '../puppet/resource/type'
+require 'monitor'
+
+require_relative 'parser/compiler/catalog_validator/relationship_validator'
+
+# PUP-3274 This should probably go someplace else
+class Puppet::LexError < RuntimeError; end

data/lib/puppet/plugins/configuration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Configures the Puppet Plugins, by registering extension points
+# and default implementations.
+#
+# See the respective configured services for more information.
+#
+# @api private
+#
+module Puppet::Plugins
+  module Configuration
+    require_relative '../../puppet/plugins/syntax_checkers'
+    require_relative '../../puppet/syntax_checkers/base64'
+    require_relative '../../puppet/syntax_checkers/json'
+    require_relative '../../puppet/syntax_checkers/pp'
+    require_relative '../../puppet/syntax_checkers/epp'
+
+    def self.load_plugins
+      # Register extensions
+      # -------------------
+      {
+        SyntaxCheckers::SYNTAX_CHECKERS_KEY => {
+          'json' => Puppet::SyntaxCheckers::Json.new,
+          'base64' => Puppet::SyntaxCheckers::Base64.new,
+          'pp' => Puppet::SyntaxCheckers::PP.new,
+          'epp' => Puppet::SyntaxCheckers::EPP.new
+        }
+      }
+    end
+  end
+end

data/lib/puppet/plugins/syntax_checkers.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Puppet::Plugins
+module SyntaxCheckers
+  # The lookup **key** for the multibind containing syntax checkers used to syntax check embedded string in non
+  # puppet DSL syntax.
+  # @api public
+  SYNTAX_CHECKERS_KEY = :'puppet::syntaxcheckers'
+
+  # SyntaxChecker is a Puppet Extension Point for the purpose of extending Puppet with syntax checkers.
+  # The intended use is to create a class derived from this class and then register it with the Puppet context
+  #
+  # Creating the Extension Class
+  # ----------------------------
+  # As an example, a class for checking custom xml (aware of some custom schemes) may be authored in
+  # say a puppet module called 'exampleorg/xmldata'. The name of the class should start with `Puppetx::<user>::<module>`,
+  # e.g. 'Puppetx::Exampleorg::XmlData::XmlChecker" and
+  # be located in `lib/puppetx/exampleorg/xml_data/xml_checker.rb`. The Puppet Binder will auto-load this file when it
+  # has a binding to the class `Puppetx::Exampleorg::XmlData::XmlChecker'
+  # The Ruby Module `Puppetx` is created by Puppet, the remaining modules should be created by the loaded logic - e.g.:
+  #
+  # @example Defining an XmlChecker
+  #   module Puppetx::Exampleorg
+  #     module XmlData
+  #       class XmlChecker < Puppetx::Puppetlabs::SyntaxCheckers::SyntaxChecker
+  #         def check(text, syntax_identifier, acceptor, location_hash)
+  #            # do the checking
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # Implementing the check method
+  # -----------------------------
+  # The implementation of the {#check} method should naturally perform syntax checking of the given text/string and
+  # produce found issues on the given `acceptor`. These can be warnings or errors. The method should return `false` if
+  # any warnings or errors were produced (it is up to the caller to check for error/warning conditions and report them
+  # to the user).
+  #
+  # Issues are reported by calling the given `acceptor`, which takes a severity (e.g. `:error`,
+  # or `:warning), an {Puppet::Pops::Issues::Issue} instance, and a {Puppet::Pops::Adapters::SourcePosAdapter}
+  # (which describes details about linenumber, position, and length of the problem area). Note that the
+  # `location_info` given to the check method holds information about the location of the string in its *container*
+  # (e.g. the source position of a Heredoc); this information can be used if more detailed information is not
+  # available, or combined if there are more details (relative to the start of the checked string).
+  #
+  # @example Reporting an issue
+  #    # create an issue with a symbolic name (that can serve as a reference to more details about the problem),
+  #    # make the name unique
+  #    issue = Puppet::Pops::Issues::issue(:EXAMPLEORG_XMLDATA_ILLEGAL_XML) { "syntax error found in xml text" }
+  #    source_pos = Puppet::Pops::Adapters::SourcePosAdapter.new()
+  #    source_pos.line = info[:line] # use this if there is no detail from the used parser
+  #    source_pos.pos = info[:pos]   # use this pos if there is no detail from used parser
+  #
+  #    # report it
+  #    acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, info[:file], source_pos, {}))
+  #
+  # There is usually a cap on the number of errors/warnings that are presented to the user, this is handled by the
+  # reporting logic, but care should be taken to not generate too many as the issues are kept in memory until
+  # the checker returns. The acceptor may set a limit and simply ignore issues past a certain (high) number of reported
+  # issues (this number is typically higher than the cap on issues reported to the user).
+  #
+  # The `syntax_identifier`
+  # -----------------------
+  # The extension makes use of a syntax identifier written in mime-style. This identifier can be something simple
+  # as 'xml', or 'json', but can also consist of several segments joined with '+' where the most specific syntax variant
+  # is placed first. When searching for a syntax checker; say for JSON having some special traits, say 'userdata', the
+  # author of the text may indicate this as the text having the syntax "userdata+json" - when a checker is looked up it is
+  # first checked if there is a checker for "userdata+json", if none is found, a lookup is made for "json" (since the text
+  # must at least be valid json). The given identifier is passed to the checker (to allow the same checker to check for
+  # several dialects/specializations).
+  #
+  # Use in Puppet DSL
+  # -----------------
+  # The Puppet DSL Heredoc support makes use of the syntax checker extension. A user of a
+  # heredoc can specify the syntax in the heredoc tag, e.g.`@(END:userdata+json)`.
+  #
+  #
+  # @abstract
+  #
+  class SyntaxChecker
+    # Checks the text for syntax issues and reports them to the given acceptor.
+    # This implementation is abstract, it raises {NotImplementedError} since a subclass should have implemented the
+    # method.
+    #
+    # @param text [String] The text to check
+    # @param syntax_identifier [String] The syntax identifier in mime style (e.g. 'json', 'json-patch+json', 'xml', 'myapp+xml'
+    # @option location_info [String] :file The filename where the string originates
+    # @option location_info [Integer] :line The line number identifying the location where the string is being used/checked
+    # @option location_info [Integer] :position The position on the line identifying the location where the string is being used/checked
+    # @return [Boolean] Whether the checked string had issues (warnings and/or errors) or not.
+    # @api public
+    #
+    def check(text, syntax_identifier, acceptor, location_info)
+      raise NotImplementedError, "The class #{self.class.name} should have implemented the method check()"
+    end
+  end
+end
+end

data/lib/puppet/plugins.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# The Puppet Plugins module defines extension points where plugins can be configured
+# to add or modify puppet's behavior. See the respective classes in this module for more
+# details.
+#
+# @api public
+# @since Puppet 4.0.0
+#
+module Puppet::Plugins
+end