openvox 8.19.0

data/lib/puppet/pops/lookup/context.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative 'interpolation'
+
+module Puppet::Pops
+module Lookup
+# The EnvironmentContext is adapted to the current environment
+#
+class EnvironmentContext < Adaptable::Adapter
+  class FileData
+    attr_reader :data
+
+    def initialize(path, inode, mtime, size, data)
+      @path = path
+      @inode = inode
+      @mtime = mtime
+      @size = size
+      @data = data
+    end
+
+    def valid?(stat)
+      stat.ino == @inode && stat.mtime == @mtime && stat.size == @size
+    end
+  end
+
+  attr_reader :environment_name
+
+  def self.create_adapter(environment)
+    new(environment)
+  end
+
+  def initialize(environment)
+    @environment_name = environment.name
+    @file_data_cache = {}
+  end
+
+  # Loads the contents of the file given by _path_. The content is then yielded to the provided block in
+  # case a block is given, and the returned value from that block is cached and returned by this method.
+  # If no block is given, the content is stored instead.
+  #
+  # The cache is retained as long as the inode, mtime, and size of the file remains unchanged.
+  #
+  # @param path [String] path to the file to be read
+  # @yieldparam content [String] the content that was read from the file
+  # @yieldreturn [Object] some result based on the content
+  # @return [Object] the content, or if a block was given, the return value of the block
+  #
+  def cached_file_data(path)
+    file_data = @file_data_cache[path]
+    stat = Puppet::FileSystem.stat(path)
+    unless file_data && file_data.valid?(stat)
+      Puppet.debug { "File at '#{path}' was changed, reloading" } if file_data
+      content = Puppet::FileSystem.read(path, :encoding => 'utf-8')
+      file_data = FileData.new(path, stat.ino, stat.mtime, stat.size, block_given? ? yield(content) : content)
+      @file_data_cache[path] = file_data
+    end
+    file_data.data
+  end
+end
+
+# A FunctionContext is created for each unique hierarchy entry and adapted to the Compiler (and hence shares
+# the compiler's life-cycle).
+# @api private
+class FunctionContext
+  include Interpolation
+
+  attr_reader :module_name, :function
+  attr_accessor :data_hash
+
+  def initialize(environment_context, module_name, function)
+    @data_hash = nil
+    @cache = {}
+    @environment_context = environment_context
+    @module_name = module_name
+    @function = function
+  end
+
+  def cache(key, value)
+    @cache[key] = value
+  end
+
+  def cache_all(hash)
+    @cache.merge!(hash)
+    nil
+  end
+
+  def cache_has_key(key)
+    @cache.include?(key)
+  end
+
+  def cached_value(key)
+    @cache[key]
+  end
+
+  def cached_entries(&block)
+    if block_given?
+      @cache.each_pair do |pair|
+        if block.arity == 2
+          yield(*pair)
+        else
+          yield(pair)
+        end
+      end
+      nil
+    else
+      Types::Iterable.on(@cache)
+    end
+  end
+
+  def cached_file_data(path, &block)
+    @environment_context.cached_file_data(path, &block)
+  end
+
+  def environment_name
+    @environment_context.environment_name
+  end
+end
+
+# The Context is created once for each call to a function. It provides a combination of the {Invocation} object needed
+# to provide explanation support and the {FunctionContext} object needed to provide the private cache.
+# The {Context} is part of the public API. It will be passed to a _data_hash_, _data_dig_, or _lookup_key_ function and its
+# attributes and methods can be used in a Puppet function as well as in a Ruby function.
+# The {Context} is maps to the Pcore type 'Puppet::LookupContext'
+#
+# @api public
+class Context
+  include Types::PuppetObject
+  extend Forwardable
+
+  def self._pcore_type
+    @type
+  end
+
+  def self.register_ptype(loader, ir)
+    tf = Types::TypeFactory
+    key_type = tf.optional(tf.scalar)
+    @type =
+      Pcore.create_object_type(
+        loader,
+        ir,
+        self,
+        'Puppet::LookupContext',
+        'Any',
+        {
+          'environment_name' => {
+            Types::KEY_TYPE => Types::PStringType::NON_EMPTY,
+            Types::KEY_KIND => Types::PObjectType::ATTRIBUTE_KIND_DERIVED
+          },
+          'module_name' => {
+            Types::KEY_TYPE => tf.variant(Types::PStringType::NON_EMPTY, Types::PUndefType::DEFAULT)
+          }
+        },
+        {
+          'not_found' => tf.callable([0, 0], tf.undef),
+          'explain' => tf.callable([0, 0, tf.callable(0, 0)], tf.undef),
+          'interpolate' => tf.callable(1, 1),
+          'cache' => tf.callable([key_type, tf.any], tf.any),
+          'cache_all' => tf.callable([tf.hash_kv(key_type, tf.any)], tf.undef),
+          'cache_has_key' => tf.callable([key_type], tf.boolean),
+          'cached_value' => tf.callable([key_type], tf.any),
+          'cached_entries' => tf.variant(
+            tf.callable([0, 0, tf.callable(1, 1)], tf.undef),
+            tf.callable([0, 0, tf.callable(2, 2)], tf.undef),
+            tf.callable([0, 0], tf.iterable(tf.tuple([key_type, tf.any])))
+          ),
+          'cached_file_data' => tf.callable(tf.string, tf.optional(tf.callable([1, 1])))
+        }
+      ).resolve(loader)
+  end
+
+  # Mainly for test purposes. Makes it possible to create a {Context} in Puppet code provided that a current {Invocation} exists.
+  def self.from_asserted_args(module_name)
+    new(FunctionContext.new(EnvironmentContext.adapt(Puppet.lookup(:environments).get(Puppet[:environment])), module_name, nil), Invocation.current)
+  end
+
+  # Public methods delegated to the {FunctionContext}
+  def_delegators :@function_context, :cache, :cache_all, :cache_has_key, :cached_value, :cached_entries, :environment_name, :module_name, :cached_file_data
+
+  def initialize(function_context, lookup_invocation)
+    @lookup_invocation = lookup_invocation
+    @function_context = function_context
+  end
+
+  # Will call the given block to obtain a textual explanation if explanation support is active.
+  #
+  def explain(&block)
+    @lookup_invocation.report_text(&block)
+    nil
+  end
+
+  # Resolve interpolation expressions in the given value
+  # @param [Object] value
+  # @return [Object] the value with all interpolation expressions resolved
+  def interpolate(value)
+    @function_context.interpolate(value, @lookup_invocation, true)
+  end
+
+  def not_found
+    throw :no_such_key
+  end
+
+  # @api private
+  def invocation
+    @lookup_invocation
+  end
+end
+end
+end

data/lib/puppet/pops/lookup/data_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Lookup
+# A class that adapts a Hash
+# @api private
+class DataAdapter < Adaptable::Adapter
+  def self.create_adapter(o)
+    new
+  end
+
+  def initialize
+    @data = {}
+  end
+
+  def [](name)
+    @data[name]
+  end
+
+  def include?(name)
+    @data.include? name
+  end
+
+  def []=(name, value)
+    @data[name] = value
+  end
+end
+end
+end

data/lib/puppet/pops/lookup/data_dig_function_provider.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative 'function_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class DataDigFunctionProvider < FunctionProvider
+  TAG = 'data_dig'
+
+  # Performs a lookup with the assumption that a recursive check has been made.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String => Object},nil] Merge strategy, merge strategy name, strategy and options hash, or nil (implies "first found")
+  # @return [Object] the found object
+  # @throw :no_such_key when the object is not found
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    lookup_invocation.with(:data_provider, self) do
+      MergeStrategy.strategy(merge).lookup(locations, lookup_invocation) do |location|
+        invoke_with_location(lookup_invocation, location, key, merge)
+      end
+    end
+  end
+
+  def invoke_with_location(lookup_invocation, location, key, merge)
+    if location.nil?
+      key.undig(lookup_invocation.report_found(key, validated_data_dig(key, lookup_invocation, nil, merge)))
+    else
+      lookup_invocation.with(:location, location) do
+        key.undig(lookup_invocation.report_found(key, validated_data_dig(key, lookup_invocation, location, merge)))
+      end
+    end
+  end
+
+  def label
+    'Data Dig'
+  end
+
+  def validated_data_dig(key, lookup_invocation, location, merge)
+    validate_data_value(data_dig(key, lookup_invocation, location, merge)) do
+      msg = "Value for key '#{key}', returned from #{full_name}"
+      location.nil? ? msg : "#{msg}, when using location '#{location}',"
+    end
+  end
+
+  private
+
+  def data_dig(key, lookup_invocation, location, merge)
+    unless location.nil? || location.exist?
+      lookup_invocation.report_location_not_found
+      throw :no_such_key
+    end
+    ctx = function_context(lookup_invocation, location)
+    ctx.data_hash ||= {}
+    catch(:no_such_key) do
+      hash = ctx.data_hash
+      hash[key] = ctx.function.call(lookup_invocation.scope, key.to_a, options(location), Context.new(ctx, lookup_invocation)) unless hash.include?(key)
+      return hash[key]
+    end
+    lookup_invocation.report_not_found(key)
+    throw :no_such_key
+  end
+end
+
+# @api private
+class V3BackendFunctionProvider < DataDigFunctionProvider
+  TAG = 'hiera3_backend'
+
+  def data_dig(key, lookup_invocation, location, merge)
+    @backend ||= instantiate_backend(lookup_invocation)
+
+    # A merge_behavior retrieved from hiera.yaml must not be converted here. Instead, passing the symbol :hash
+    # tells the V3 backend to pick it up from the config.
+    resolution_type = lookup_invocation.hiera_v3_merge_behavior? ? :hash : convert_merge(merge)
+    @backend.lookup(key.to_s, lookup_invocation.scope, lookup_invocation.hiera_v3_location_overrides, resolution_type, { :recurse_guard => nil })
+  end
+
+  def full_name
+    "hiera version 3 backend '#{options[HieraConfig::KEY_BACKEND]}'"
+  end
+
+  def value_is_validated?
+    false
+  end
+
+  private
+
+  def instantiate_backend(lookup_invocation)
+    backend_name = options[HieraConfig::KEY_BACKEND]
+    begin
+      require 'hiera/backend'
+      require "hiera/backend/#{backend_name.downcase}_backend"
+      backend = Hiera::Backend.const_get("#{backend_name.capitalize}_backend").new
+      backend.method(:lookup).arity == 4 ? Hiera::Backend::Backend1xWrapper.new(backend) : backend
+    rescue LoadError => e
+      lookup_invocation.report_text { "Unable to load backend '#{backend_name}': #{e.message}" }
+      throw :no_such_key
+    rescue NameError => e
+      lookup_invocation.report_text { "Unable to instantiate backend '#{backend_name}': #{e.message}" }
+      throw :no_such_key
+    end
+  end
+
+  # Converts a lookup 'merge' parameter argument into a Hiera 'resolution_type' argument.
+  #
+  # @param merge [String,Hash,nil] The lookup 'merge' argument
+  # @return [Symbol,Hash,nil] The Hiera 'resolution_type'
+  def convert_merge(merge)
+    case merge
+    when nil, 'first', 'default'
+      # Nil is OK. Defaults to Hiera :priority
+      nil
+    when Puppet::Pops::MergeStrategy
+      convert_merge(merge.configuration)
+    when 'unique'
+      # Equivalent to Hiera :array
+      :array
+    when 'hash'
+      # Equivalent to Hiera :hash with default :native merge behavior. A Hash must be passed here
+      # to override possible Hiera deep merge config settings.
+      { :behavior => :native }
+    when 'deep', 'unconstrained_deep'
+      # Equivalent to Hiera :hash with :deeper merge behavior.
+      { :behavior => :deeper }
+    when 'reverse_deep'
+      # Equivalent to Hiera :hash with :deep merge behavior.
+      { :behavior => :deep }
+    when Hash
+      strategy = merge['strategy']
+      case strategy
+      when 'deep', 'unconstrained_deep', 'reverse_deep'
+        result = { :behavior => strategy == 'reverse_deep' ? :deep : :deeper }
+        # Remaining entries must have symbolic keys
+        merge.each_pair { |k, v| result[k.to_sym] = v unless k == 'strategy' }
+        result
+      else
+        convert_merge(strategy)
+      end
+    else
+      raise Puppet::DataBinding::LookupError, "Unrecognized value for request 'merge' parameter: '#{merge}'"
+    end
+  end
+end
+end
+end

data/lib/puppet/pops/lookup/data_hash_function_provider.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative 'function_provider'
+require_relative 'interpolation'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class DataHashFunctionProvider < FunctionProvider
+  include SubLookup
+  include Interpolation
+
+  TAG = 'data_hash'
+
+  def self.trusted_return_type
+    @trusted_return_type ||= Types::PHashType.new(DataProvider.key_type, DataProvider.value_type)
+  end
+
+  # Performs a lookup with the assumption that a recursive check has been made.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String => Object},nil] Merge strategy, merge strategy name, strategy and options hash, or nil (implies "first found")
+  # @return [Object] the found object
+  # @throw :no_such_key when the object is not found
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    root_key = key.root_key
+    lookup_invocation.with(:data_provider, self) do
+      MergeStrategy.strategy(merge).lookup(locations, lookup_invocation) do |location|
+        invoke_with_location(lookup_invocation, location, root_key)
+      end
+    end
+  end
+
+  private
+
+  def invoke_with_location(lookup_invocation, location, root_key)
+    if location.nil?
+      lookup_key(lookup_invocation, nil, root_key)
+    else
+      lookup_invocation.with(:location, location) do
+        if location.exist?
+          lookup_key(lookup_invocation, location, root_key)
+        else
+          lookup_invocation.report_location_not_found
+          throw :no_such_key
+        end
+      end
+    end
+  end
+
+  def lookup_key(lookup_invocation, location, root_key)
+    lookup_invocation.report_found(root_key, data_value(lookup_invocation, location, root_key))
+  end
+
+  def data_value(lookup_invocation, location, root_key)
+    hash = data_hash(lookup_invocation, location)
+    value = hash[root_key]
+    if value.nil? && !hash.include?(root_key)
+      lookup_invocation.report_not_found(root_key)
+      throw :no_such_key
+    end
+    value = validate_data_value(value) do
+      msg = "Value for key '#{root_key}', in hash returned from #{full_name}"
+      location.nil? ? msg : "#{msg}, when using location '#{location}',"
+    end
+    interpolate(value, lookup_invocation, true)
+  end
+
+  def data_hash(lookup_invocation, location)
+    ctx = function_context(lookup_invocation, location)
+    ctx.data_hash ||= parent_data_provider.validate_data_hash(call_data_hash_function(ctx, lookup_invocation, location)) do
+      msg = "Value returned from #{full_name}"
+      location.nil? ? msg : "#{msg}, when using location '#{location}',"
+    end
+  end
+
+  def call_data_hash_function(ctx, lookup_invocation, location)
+    ctx.function.call(lookup_invocation.scope, options(location), Context.new(ctx, lookup_invocation))
+  end
+end
+
+# @api private
+class V3DataHashFunctionProvider < DataHashFunctionProvider
+  TAG = 'v3_data_hash'
+
+  def initialize(name, parent_data_provider, function_name, options, locations)
+    @datadir = options.delete(HieraConfig::KEY_DATADIR)
+    super
+  end
+
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    extra_paths = lookup_invocation.hiera_v3_location_overrides
+    if extra_paths.nil? || extra_paths.empty?
+      super
+    else
+      # Extra paths provided. Must be resolved and placed in front of known paths
+      paths = parent_data_provider.config(lookup_invocation).resolve_paths(@datadir, extra_paths, lookup_invocation, false, ".#{@name}")
+      all_locations = paths + locations
+      root_key = key.root_key
+      lookup_invocation.with(:data_provider, self) do
+        MergeStrategy.strategy(merge).lookup(all_locations, lookup_invocation) do |location|
+          invoke_with_location(lookup_invocation, location, root_key)
+        end
+      end
+    end
+  end
+end
+
+# TODO: API 5.0, remove this class
+# @api private
+class V4DataHashFunctionProvider < DataHashFunctionProvider
+  TAG = 'v4_data_hash'
+
+  def name
+    "Deprecated API function \"#{function_name}\""
+  end
+
+  def full_name
+    "deprecated API function '#{function_name}'"
+  end
+
+  def call_data_hash_function(ctx, lookup_invocation, location)
+    ctx.function.call(lookup_invocation.scope)
+  end
+end
+end
+end

data/lib/puppet/pops/lookup/data_provider.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Lookup
+# @api private
+module DataProvider
+  def self.key_type
+    @key_type
+  end
+
+  def self.value_type
+    @value_type
+  end
+
+  def self.register_types(loader)
+    tp = Types::TypeParser.singleton
+    @key_type = tp.parse('RichDataKey', loader)
+    @value_type = tp.parse('RichData', loader)
+  end
+
+  # Performs a lookup with an endless recursion check.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String=>Object},nil] Merge strategy or hash with strategy and options
+  #
+  def key_lookup(key, lookup_invocation, merge)
+    lookup_invocation.check(key.to_s) { unchecked_key_lookup(key, lookup_invocation, merge) }
+  end
+
+  # Performs a lookup using a module default hierarchy with an endless recursion check. All providers except
+  # the `ModuleDataProvider` will throw `:no_such_key` if this method is called.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String=>Object},nil] Merge strategy or hash with strategy and options
+  #
+  def key_lookup_in_default(key, lookup_invocation, merge)
+    throw :no_such_key
+  end
+
+  def lookup(key, lookup_invocation, merge)
+    lookup_invocation.check(key.to_s) { unchecked_key_lookup(key, lookup_invocation, merge) }
+  end
+
+  # Performs a lookup with the assumption that a recursive check has been made.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String => Object},nil] Merge strategy, merge strategy name, strategy and options hash, or nil (implies "first found")
+  # @return [Object] the found object
+  # @throw :no_such_key when the object is not found
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    raise NotImplementedError, "Subclass of #{DataProvider.name} must implement 'unchecked_lookup' method"
+  end
+
+  # @return [String,nil] the name of the module that this provider belongs to nor `nil` if it doesn't belong to a module
+  def module_name
+    nil
+  end
+
+  # @return [String] the name of the this data provider
+  def name
+    raise NotImplementedError, "Subclass of #{DataProvider.name} must implement 'name' method"
+  end
+
+  # @returns `true` if the value provided by this instance can always be trusted, `false` otherwise
+  def value_is_validated?
+    false
+  end
+
+  # Asserts that _data_hash_ is a hash. Will yield to obtain origin of value in case an error is produced
+  #
+  # @param data_hash [Hash{String=>Object}] The data hash
+  # @return [Hash{String=>Object}] The data hash
+  def validate_data_hash(data_hash, &block)
+    Types::TypeAsserter.assert_instance_of(nil, Types::PHashType::DEFAULT, data_hash, &block)
+  end
+
+  # Asserts that _data_value_ is of valid type. Will yield to obtain origin of value in case an error is produced
+  #
+  # @param data_provider [DataProvider] The data provider that produced the hash
+  # @return [Object] The data value
+  def validate_data_value(value, &block)
+    # The DataProvider.value_type is self recursive so further recursive check of collections is needed here
+    unless value_is_validated? || DataProvider.value_type.instance?(value)
+      actual_type = Types::TypeCalculator.singleton.infer(value)
+      raise Types::TypeAssertionError.new("#{yield} has wrong type, expects Puppet::LookupValue, got #{actual_type}", DataProvider.value_type, actual_type)
+    end
+    value
+  end
+end
+end
+end

data/lib/puppet/pops/lookup/environment_data_provider.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'configured_data_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class EnvironmentDataProvider < ConfiguredDataProvider
+  def place
+    'Environment'
+  end
+
+  protected
+
+  def assert_config_version(config)
+    if config.version > 3
+      config
+    else
+      if Puppet[:strict] == :error
+        config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'environment')
+      else
+        Puppet.warn_once(:hiera_v3_at_env_root, config.config_path, _('hiera.yaml version 3 found at the environment root was ignored'), config.config_path)
+      end
+      nil
+    end
+  end
+
+  # Return the root of the environment
+  #
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @return [Pathname] Path to root of the environment
+  def provider_root(lookup_invocation)
+    Pathname.new(lookup_invocation.scope.environment.configuration.path_to_env)
+  end
+end
+end
+end