bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/parser/functions/tag.rb

@@ -0,0 +1,12 @@
+# Tag the current scope with each passed name
+Puppet::Parser::Functions::newfunction(:tag, :arity => -2, :doc => "Add the specified tags to the containing class
+  or definition.  All contained objects will then acquire that tag, also.
+  ") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tag'})
+    end
+
+    self.resource.tag(*vals)
+end

data/vendored/puppet/lib/puppet/parser/functions/tagged.rb

@@ -0,0 +1,24 @@
+# Test whether a given tag is set.  This functions as a big OR -- if any of the specified tags are unset, we return false.
+Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2, :doc => "A boolean function that
+  tells you whether the current container is tagged with the specified tags.
+  The tags are ANDed, so that all of the specified tags must be included for
+  the function to return true.") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:operation => 'tagged'})
+    end
+
+    configtags = compiler.catalog.tags
+    resourcetags = resource.tags
+
+    retval = true
+    vals.each do |val|
+      unless configtags.include?(val) or resourcetags.include?(val)
+        retval = false
+        break
+      end
+    end
+
+    return retval
+end

data/vendored/puppet/lib/puppet/parser/functions/template.rb

@@ -0,0 +1,39 @@
+Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2, :doc =>
+  "Loads an ERB template from a module, evaluates it, and returns the resulting
+  value as a string.
+
+  The argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+  reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+  directory. (For example, the reference `apache/vhost.conf.erb` will load the
+  file `<MODULES DIRECTORY>/apache/templates/vhost.conf.erb`.)
+
+  This function can also accept:
+
+  * An absolute path, which can load a template file from anywhere on disk.
+  * Multiple arguments, which will evaluate all of the specified templates and
+  return their outputs concatenated into a single string.") do |vals|
+    if Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
+        {:feature => 'ERB template'})
+    end
+    vals.collect do |file|
+      # Use a wrapper, so the template can't get access to the full
+      # Scope object.
+      debug "Retrieving template #{file}"
+
+      wrapper = Puppet::Parser::TemplateWrapper.new(self)
+      wrapper.file = file
+      begin
+        wrapper.result
+      rescue => detail
+        info = detail.backtrace.first.split(':')
+        message = []
+        message << _("Failed to parse template %{file}:") % { file: file }
+        message << _("  Filepath: %{file_path}") % { file_path: info[0] }
+        message << _("  Line: %{line}") % { line: info[1] }
+        message << _("  Detail: %{detail}") % { detail: detail }
+        raise Puppet::ParseError, message.join("\n") + "\n"
+      end
+    end.join("")
+end

data/vendored/puppet/lib/puppet/parser/functions/then.rb

@@ -0,0 +1,73 @@
+Puppet::Parser::Functions::newfunction(
+  :then,
+  :type => :rvalue,
+  :arity => -2,
+  :doc => <<-DOC
+Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+with the given argument unless the argument is undef. Return `undef` if argument is
+`undef`, and otherwise the result of giving the argument to the lambda.
+
+This is useful to process a sequence of operations where an intermediate
+result may be `undef` (which makes the entire sequence `undef`).
+The `then` function is especially useful with the function `dig` which
+performs in a similar way "digging out" a value in a complex structure.
+
+**Example:** Using `dig` and `then`
+
+```puppet
+$data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
+notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
+```
+
+Would notice the value 200
+
+Contrast this with:
+
+```puppet
+$data = {a => { b => [{x => 10, y => 20}, {ex => 100, why => 200}]}}
+notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
+```
+
+Which would notice `undef` since the last lookup of 'x' results in `undef` which
+is returned (without calling the lambda given to the `then` function).
+
+As a result there is no need for conditional logic or a temporary (non local)
+variable as the result is now either the wanted value (`x`) multiplied
+by 2 or `undef`.
+
+Calls to `then` can be chained. In the next example, a structure is using an offset based on
+using 1 as the index to the first element (instead of 0 which is used in the language).
+We are not sure if user input actually contains an index at all, or if it is
+outside the range of available names.args.
+
+**Example:** Chaining calls to the `then` function
+
+```puppet
+# Names to choose from
+$names = ['Ringo', 'Paul', 'George', 'John']
+
+# Structure where 'beatle 2' is wanted (but where the number refers
+# to 'Paul' because input comes from a source using 1 for the first
+# element).
+
+$data = ['singer', { beatle => 2 }]
+$picked = assert_type(String,
+  # the data we are interested in is the second in the array,
+  # a hash, where we want the value of the key 'beatle'
+  $data.dig(1, 'beatle')
+    # and we want the index in $names before the given index
+    .then |$x| { $names[$x-1] }
+    # so we can construct a string with that beatle's name
+    .then |$x| { "Picked Beatle '${x}'" }
+)
+```
+
+Would notice "Picked Beatle 'Paul'", and would raise an error if the result
+was not a String.
+
+* Since 4.5.0
+
+DOC
+) do |args|
+  Puppet::Parser::Functions::Error.is4x('then')
+end

data/vendored/puppet/lib/puppet/parser/functions/type.rb

@@ -0,0 +1,53 @@
+Puppet::Parser::Functions::newfunction(
+  :type,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Returns the data type of a given value with a given degree of generality.
+
+```puppet
+type InferenceFidelity = Enum[generalized, reduced, detailed]
+
+function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Type
+```
+
+ **Example:** Using `type`
+
+ ``` puppet
+ notice type(42) =~ Type[Integer]
+ ```
+
+ Would notice `true`.
+
+ By default, the best possible inference is made where all details are retained.
+ This is good when the type is used for further type calculations but is overwhelmingly
+ rich in information if it is used in a error message.
+
+ The optional argument `$fidelity` may be given as (from lowest to highest fidelity):
+
+ * `generalized` - reduces to common type and drops size constraints
+ * `reduced` - reduces to common type in collections
+ * `detailed` - (default) all details about inferred types is retained
+
+ **Example:** Using `type()` with different inference fidelity:
+
+ ``` puppet
+ notice type([3.14, 42], 'generalized')
+ notice type([3.14, 42], 'reduced'')
+ notice type([3.14, 42], 'detailed')
+ notice type([3.14, 42])
+ ```
+
+ Would notice the four values:
+
+ 1. 'Array[Numeric]'
+ 2. 'Array[Numeric, 2, 2]'
+ 3. 'Tuple[Float[3.14], Integer[42,42]]]'
+ 4. 'Tuple[Float[3.14], Integer[42,42]]]'
+
+ * Since 4.4.0
+
+DOC
+) do |args|
+  Puppet::Parser::Functions::Error.is4x('type')
+end

data/vendored/puppet/lib/puppet/parser/functions/versioncmp.rb

@@ -0,0 +1,30 @@
+require 'puppet/util/package'
+
+Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue, :arity => 2, :doc =>
+"Compares two version numbers.
+
+Prototype:
+
+    \$result = versioncmp(a, b)
+
+Where a and b are arbitrary version strings.
+
+This function returns:
+
+* `1` if version a is greater than version b
+* `0` if the versions are equal
+* `-1` if version a is less than version b
+
+Example:
+
+    if versioncmp('2.6-1', '2.4.5') > 0 {
+        notice('2.6-1 is > than 2.4.5')
+    }
+
+This function uses the same version comparison algorithm used by Puppet's
+`package` type.
+
+") do |args|
+
+  return Puppet::Util::Package.versioncmp(args[0], args[1])
+end

data/vendored/puppet/lib/puppet/parser/functions/with.rb

@@ -0,0 +1,28 @@
+Puppet::Parser::Functions::newfunction(
+  :with,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Call a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+with the given arguments and return the result. Since a lambda's scope is
+[local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
+to the lambda, you can use the `with` function to create private blocks of code within a
+class using variables whose values cannot be accessed outside of the lambda.
+
+**Example**: Using `with`
+
+~~~ puppet
+# Concatenate three strings into a single string formatted as a list.
+$fruit = with("apples", "oranges", "bananas") |$x, $y, $z| {
+  "${x}, ${y}, and ${z}"
+}
+$check_var = $x
+# $fruit contains "apples, oranges, and bananas"
+# $check_var is undefined, as the value of $x is local to the lambda.
+~~~
+
+- Since 4.0.0
+DOC
+) do |args|
+  Puppet::Parser::Functions::Error.is4x('with')
+end

data/vendored/puppet/lib/puppet/parser/parser_factory.rb

@@ -0,0 +1,30 @@
+module Puppet; end
+
+module Puppet::Parser
+  # The ParserFactory makes selection of parser possible.
+  # Currently, it is possible to switch between two different parsers:
+  # * classic_parser, the parser in 3.1
+  # * eparser, the Expression Based Parser
+  #
+  class ParserFactory
+    # Produces a parser instance for the given environment
+    def self.parser
+      evaluating_parser
+    end
+
+    # Creates an instance of an E4ParserAdapter that adapts an
+    # EvaluatingParser to the 3x way of parsing.
+    #
+    def self.evaluating_parser
+      unless defined?(Puppet::Parser::E4ParserAdapter)
+        require 'puppet/parser/e4_parser_adapter'
+        require 'puppet/pops/parser/code_merger'
+      end
+      E4ParserAdapter.new
+    end
+
+    def self.code_merger
+      Puppet::Pops::Parser::CodeMerger.new
+    end
+  end
+end

data/vendored/puppet/lib/puppet/parser/relationship.rb

@@ -0,0 +1,83 @@
+class Puppet::Parser::Relationship
+  attr_accessor :source, :target, :type
+
+  PARAM_MAP = {:relationship => :before, :subscription => :notify}
+
+  def arrayify(resources, left)
+    case resources
+    when Puppet::Pops::Evaluator::Collectors::AbstractCollector
+      # on the LHS, go as far left as possible, else whatever the collected result is
+      left ? leftmost_alternative(resources) : resources.collected.values
+    when Array
+      resources
+    else
+      [resources]
+    end
+  end
+
+  def evaluate(catalog)
+    arrayify(source, true).each do |s|
+      arrayify(target, false).each do |t|
+        mk_relationship(s, t, catalog)
+      end
+    end
+  end
+
+  def initialize(source, target, type)
+    @source, @target, @type = source, target, type
+  end
+
+  def param_name
+    PARAM_MAP[type] || raise(ArgumentError, _("Invalid relationship type %{relationship_type}") % { relationship_type: type })
+  end
+
+  def mk_relationship(source, target, catalog)
+    source_ref = canonical_ref(source)
+    target_ref = canonical_ref(target)
+    rel_param = param_name
+
+    unless source_resource = catalog.resource(*source_ref)
+      raise ArgumentError, _("Could not find resource '%{source}' for relationship on '%{target}'") % { source: source.to_s, target: target.to_s }
+    end
+    unless catalog.resource(*target_ref)
+      raise ArgumentError, _("Could not find resource '%{target}' for relationship from '%{source}'") % { target: target.to_s, source: source.to_s }
+    end
+    Puppet.debug {"Adding relationship from #{source} to #{target} with '#{param_name}'"}
+    if source_resource[rel_param].class != Array
+      source_resource[rel_param] = [source_resource[rel_param]].compact
+    end
+    source_resource[rel_param] << (target_ref[1].nil? ? target_ref[0] : "#{target_ref[0]}[#{target_ref[1]}]")
+  end
+
+  private
+
+  # Finds the leftmost alternative for a collector (if it is empty, try its empty alternative recursively until there is
+  # either nothing left, or a non empty set is found.
+  #
+  def leftmost_alternative(x)
+    if x.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+      collected = x.collected
+      return collected.values unless collected.empty?
+      adapter = Puppet::Pops::Adapters::EmptyAlternativeAdapter.get(x)
+      adapter.nil? ? [] : leftmost_alternative(adapter.empty_alternative)
+    elsif x.is_a?(Array) && x.size == 1 && x[0].is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+      leftmost_alternative(x[0])
+    else
+      x
+    end
+  end
+
+  # Turns a PResourceType or PClassType into an array [type, title] and all other references to [ref, nil]
+  # This is needed since it is not possible to find resources in the catalog based on the type system types :-(
+  # (note, the catalog is also used on the agent side)
+  def canonical_ref(ref)
+    case ref
+    when Puppet::Pops::Types::PResourceType
+      [ref.type_name, ref.title]
+    when Puppet::Pops::Types::PClassType
+      ['class', ref.class_name]
+    else
+      [ref.to_s, nil]
+    end
+  end
+end

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

@@ -0,0 +1,417 @@
+require 'puppet/resource'
+
+# The primary difference between this class and its
+# parent is that this class has rules on who can set
+# parameters
+class Puppet::Parser::Resource < Puppet::Resource
+  require 'puppet/parser/resource/param'
+  require 'puppet/util/tagging'
+
+  include Puppet::Util
+  include Puppet::Util::MethodHelper
+  include Puppet::Util::Errors
+  include Puppet::Util::Logging
+
+  attr_accessor :source, :scope, :collector_id
+  attr_accessor :virtual, :override, :translated, :catalog, :evaluated
+  attr_accessor :file, :line
+
+  attr_reader :exported, :parameters
+
+  # Determine whether the provided parameter name is a relationship parameter.
+  def self.relationship_parameter?(name)
+    @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
+    @relationship_names.include?(name)
+  end
+
+  # Set up some boolean test methods
+  def translated?; !!@translated; end
+  def override?;   !!@override;   end
+  def evaluated?;  !!@evaluated;  end
+
+  def [](param)
+    param = param.intern
+    if param == :title
+      return self.title
+    end
+    if @parameters.has_key?(param)
+      @parameters[param].value
+    else
+      nil
+    end
+  end
+
+  def eachparam
+    @parameters.each do |name, param|
+      yield param
+    end
+  end
+
+  def environment
+    scope.environment
+  end
+
+  # Process the  stage metaparameter for a class.   A containment edge
+  # is drawn from  the class to the stage.   The stage for containment
+  # defaults to main, if none is specified.
+  def add_edge_to_stage
+    return unless self.class?
+
+    unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
+      raise ArgumentError, _("Could not find stage %{stage} specified by %{resource}") % { stage: self[:stage] || :main, resource: self }
+    end
+
+    self[:stage] ||= stage.title unless stage.title == :main
+    catalog.add_edge(stage, self)
+  end
+
+  # Retrieve the associated definition and evaluate it.
+  def evaluate
+    return if evaluated?
+    Puppet::Util::Profiler.profile(_("Evaluated resource %{res}") % { res: self }, [:compiler, :evaluate_resource, self]) do
+      @evaluated = true
+      if builtin_type?
+        devfail "Cannot evaluate a builtin type (#{type})"
+      elsif resource_type.nil?
+        self.fail "Cannot find definition #{type}"
+      else
+        finish_evaluation() # do not finish completely (as that destroys Sensitive data)
+        resource_type.evaluate_code(self)
+      end
+    end
+  end
+
+  # Mark this resource as both exported and virtual,
+  # or remove the exported mark.
+  def exported=(value)
+    if value
+      @virtual = true
+      @exported = value
+    else
+      @exported = value
+    end
+  end
+
+  # Finish the evaluation by assigning defaults and scope tags
+  # @api private
+  #
+  def finish_evaluation
+    return if @evaluation_finished
+    add_scope_tags
+    @evaluation_finished = true
+  end
+
+  # Do any finishing work on this object, called before
+  # storage/translation. The method does nothing the second time
+  # it is called on the same resource.
+  #
+  # @param do_validate [Boolean] true if validation should be performed
+  #
+  # @api private
+  def finish(do_validate = true)
+    return if finished?
+    @finished = true
+    finish_evaluation
+    replace_sensitive_data
+    validate if do_validate
+  end
+
+  # Has this resource already been finished?
+  def finished?
+    @finished
+  end
+
+  def initialize(type, title, attributes, with_defaults = true)
+    raise ArgumentError, _('Resources require a hash as last argument') unless attributes.is_a? Hash
+    raise ArgumentError, _('Resources require a scope') unless attributes[:scope]
+    super(type, title, attributes)
+
+    @source ||= scope.source
+
+    if with_defaults
+      scope.lookupdefaults(self.type).each_pair do |name, param|
+        unless @parameters.include?(name)
+          self.debug "Adding default for #{name}"
+
+          param = param.dup
+          @parameters[name] = param
+          tag(*param.value) if param.name == :tag
+        end
+      end
+    end
+  end
+
+  # Is this resource modeling an isomorphic resource type?
+  def isomorphic?
+    if builtin_type?
+      return resource_type.isomorphic?
+    else
+      return true
+    end
+  end
+
+  def is_unevaluated_consumer?
+    # We don't declare a new variable here just to test. Saves memory
+    instance_variable_defined?(:@unevaluated_consumer)
+  end
+
+  def mark_unevaluated_consumer
+    @unevaluated_consumer = true
+  end
+
+  # Merge an override resource in.  This will throw exceptions if
+  # any overrides aren't allowed.
+  def merge(resource)
+    # Test the resource scope, to make sure the resource is even allowed
+    # to override.
+    unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
+      raise Puppet::ParseError.new(_("Only subclasses can override parameters"), resource.file, resource.line)
+    end
+
+    if evaluated?
+      error_location_str = Puppet::Util::Errors.error_location(file, line)
+      msg = if error_location_str.empty?
+              _('Attempt to override an already evaluated resource with new values')
+            else
+              _('Attempt to override an already evaluated resource, defined at %{error_location}, with new values') % { error_location: error_location_str }
+            end
+      strict = Puppet[:strict]
+      unless strict == :off
+        if strict == :error
+          raise Puppet::ParseError.new(msg, resource.file, resource.line)
+        else
+          msg += Puppet::Util::Errors.error_location_with_space(resource.file, resource.line)
+          Puppet.warning(msg)
+        end
+      end
+    end
+
+    # Some of these might fail, but they'll fail in the way we want.
+    resource.parameters.each do |name, param|
+      override_parameter(param)
+    end
+  end
+
+  def name
+    self[:name] || self.title
+  end
+
+  # A temporary occasion, until I get paths in the scopes figured out.
+  alias path to_s
+
+  # Define a parameter in our resource.
+  # if we ever receive a parameter named 'tag', set
+  # the resource tags with its value.
+  def set_parameter(param, value = nil)
+    if ! param.is_a?(Puppet::Parser::Resource::Param)
+      param = param.name if param.is_a?(Puppet::Pops::Resource::Param)
+      param = Puppet::Parser::Resource::Param.new(
+        :name => param, :value => value, :source => self.source
+      )
+    end
+
+    tag(*param.value) if param.name == :tag
+
+    # And store it in our parameter hash.
+    @parameters[param.name] = param
+  end
+  alias []= set_parameter
+
+  def to_hash
+    parse_title.merge(@parameters.reduce({}) do |result, (_, param)|
+      value = param.value
+      value = (:undef == value) ? nil : value
+
+      unless value.nil?
+        case param.name
+        when :before, :subscribe, :notify, :require
+          if value.is_a?(Array)
+            value = value.flatten.reject {|v| v.nil? || :undef == v }
+          end
+          result[param.name] = value
+        else
+          result[param.name] = value
+        end
+      end
+      result
+    end)
+  end
+
+  # Convert this resource to a RAL resource.
+  def to_ral
+    copy_as_resource.to_ral
+  end
+
+  # 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.
+  #
+  # @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
+
+  # Fills resource params from a capability
+  #
+  # This backs 'consumes => Sql[one]'
+  # @api private
+  def add_parameters_from_consume
+    return if self[:consume].nil?
+
+    map = {}
+    [ self[:consume] ].flatten.map do |ref|
+      # Assert that the ref really is a resource reference
+      raise Puppet::Error, _("Invalid consume in %{value0}: %{ref} is not a resource") % { value0: self.ref, ref: ref } unless ref.is_a?(Puppet::Resource)
+
+      # Resolve references
+      t = ref.type
+      t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
+      cap = catalog.resource(t, ref.title)
+      if cap.nil?
+        raise Puppet::Error, _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
+      end
+
+      # Ensure that the found resource is a capability resource
+      raise Puppet::Error, _("Invalid consume in %{ref}: %{cap} is not a capability resource") % { ref: ref, cap: cap } unless cap.resource_type.is_capability?
+      cap
+    end.each do |cns|
+      # Establish mappings
+      blueprint = resource_type.consumes.find do |bp|
+        bp[:capability] == cns.type
+      end
+      # @todo lutter 2015-08-03: catch this earlier, can we do this during
+      # static analysis ?
+      raise _("Resource %{res} tries to consume %{cns} but no 'consumes' mapping exists for %{resource_type} and %{cns_type}") % { res: self, cns: cns, resource_type: self.resource_type, cns_type: cns.type } unless blueprint
+
+      # setup scope that has, for each attr of cns, a binding to cns[attr]
+      scope.with_global_scope do |global_scope|
+        cns_scope = global_scope.newscope(:source => self, :resource => self)
+        cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
+
+        # evaluate mappings in that scope
+        resource_type.arguments.keys.each do |name|
+          if expr = blueprint[:mappings][name]
+            # Explicit mapping
+            value = expr.safeevaluate(cns_scope)
+          else
+            value = cns[name]
+          end
+          unless value.nil?
+            # @todo lutter 2015-07-01: this should be caught by the checker
+            # much earlier. We consume several capres, at least two of which
+            # want to map to the same parameter (PUP-5080)
+            raise _("Attempt to reassign attribute '%{name}' in '%{resource}' caused by multiple consumed mappings to the same attribute") % { name: name, resource: self } if map[name]
+            map[name] = value
+          end
+        end
+      end
+    end
+
+    map.each { |name, value| self[name] = value if self[name].nil? }
+  end
+
+  def offset
+    nil
+  end
+
+  def pos
+    nil
+  end
+
+  private
+
+  def add_scope_tags
+    scope_resource = scope.resource
+    unless scope_resource.nil? || scope_resource.equal?(self)
+      merge_tags_from(scope_resource)
+    end
+  end
+
+  def replace_sensitive_data
+    parameters.each_pair do |name, param|
+      if param.value.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+        @sensitive_parameters << name
+        param.value = param.value.unwrap
+      end
+    end
+  end
+
+  # Accept a parameter from an override.
+  def override_parameter(param)
+    # This can happen if the override is defining a new parameter, rather
+    # than replacing an existing one.
+    (set_parameter(param) and return) unless current = @parameters[param.name]
+
+    # Parameter is already set - if overriding with a default - simply ignore the setting of the default value
+    return if scope.is_default?(type, param.name, param.value)
+
+    # The parameter is already set.  Fail if they're not allowed to override it.
+    unless param.source.child_of?(current.source) || param.source.equal?(current.source) && scope.is_default?(type, param.name, current.value)
+      error_location_str = Puppet::Util::Errors.error_location(current.file, current.line)
+      msg = if current.source.to_s == ''
+              if error_location_str.empty?
+                _("Parameter '%{name}' is already set on %{resource}; cannot redefine") %
+                    { name: param.name, resource: ref }
+              else
+                _("Parameter '%{name}' is already set on %{resource} at %{error_location}; cannot redefine") %
+                    { name: param.name, resource: ref, error_location: error_location_str }
+              end
+            else
+              if error_location_str.empty?
+                _("Parameter '%{name}' is already set on %{resource} by %{source}; cannot redefine") %
+                    { name: param.name, resource: ref, source: current.source.to_s }
+              else
+                _("Parameter '%{name}' is already set on %{resource} by %{source} at %{error_location}; cannot redefine") %
+                    { name: param.name, resource: ref, source: current.source.to_s, error_location: error_location_str }
+              end
+            end
+      raise Puppet::ParseError.new(msg, param.file, param.line)
+    end
+
+    # If we've gotten this far, we're allowed to override.
+
+    # Merge with previous value, if the parameter was generated with the +>
+    # syntax.  It's important that we use a copy of the new param instance
+    # here, not the old one, and not the original new one, so that the source
+    # is registered correctly for later overrides but the values aren't
+    # implicitly shared when multiple resources are overridden at once (see
+    # ticket #3556).
+    if param.add
+      param = param.dup
+      param.value = [current.value, param.value].flatten
+    end
+
+    set_parameter(param)
+  end
+
+  # Make sure the resource's parameters are all valid for the type.
+  def validate
+    if builtin_type?
+      begin
+        @parameters.each { |name, value| validate_parameter(name) }
+      rescue => detail
+        self.fail Puppet::ParseError, detail.to_s + " on #{self}", detail
+      end
+    else
+      resource_type.validate_resource(self)
+    end
+  end
+
+  def extract_parameters(params)
+    params.each do |param|
+      # Don't set the same parameter twice
+      self.fail Puppet::ParseError, _("Duplicate parameter '%{param}' for on %{resource}") % { param: param.name, resource: self } if @parameters[param.name]
+
+      set_parameter(param)
+    end
+  end
+end