bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,96 @@
+# This class is the backing implementation of the Puppet function 'lookup'.
+# See puppet/functions/lookup.rb for documentation.
+#
+module Puppet::Pops
+module Lookup
+  LOOKUP_OPTIONS = 'lookup_options'.freeze
+  GLOBAL = '__global__'.freeze
+
+  # Performs a lookup in the configured scopes and optionally merges the default.
+  #
+  # This is a backing function and all parameters are assumed to have been type checked.
+  # See puppet/functions/lookup.rb for full documentation and all parameter combinations.
+  #
+  # @param name [String|Array<String>] The name or names to lookup
+  # @param type [Types::PAnyType|nil] The expected type of the found value
+  # @param default_value [Object] The value to use as default when no value is found
+  # @param has_default [Boolean] Set to _true_ if _default_value_ is included (_nil_ is a valid _default_value_)
+  # @param merge [MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  # @param lookup_invocation [Invocation] Invocation data containing scope, overrides, and defaults
+  # @return [Object] The found value
+  #
+  def self.lookup(name, value_type, default_value, has_default, merge, lookup_invocation)
+    names = name.is_a?(Array) ? name : [name]
+
+    # find first name that yields a non-nil result and wrap it in a two element array
+    # with name and value.
+    not_found = MergeStrategy::NOT_FOUND
+    override_values = lookup_invocation.override_values
+    result_with_name = names.reduce([nil, not_found]) do |memo, key|
+      value = override_values.include?(key) ? assert_type(["Value found for key '%s' in override hash", key], value_type, override_values[key]) : not_found
+      catch(:no_such_key) { value = search_and_merge(key, lookup_invocation, merge, false) } if value.equal?(not_found)
+      break [key, assert_type('Found value', value_type, value)] unless value.equal?(not_found)
+      memo
+    end
+
+    # Use the 'default_values' hash as a last resort if nothing is found
+    if result_with_name[1].equal?(not_found)
+      default_values = lookup_invocation.default_values
+      unless default_values.empty?
+        result_with_name = names.reduce(result_with_name) do |memo, key|
+          value = default_values.include?(key) ? assert_type(["Value found for key '%s' in default values hash", key], value_type, default_values[key]) : not_found
+          memo = [key, value]
+          break memo unless value.equal?(not_found)
+          memo
+        end
+      end
+    end
+
+    answer = result_with_name[1]
+    if answer.equal?(not_found)
+      if block_given?
+        answer = assert_type('Value returned from default block', value_type, yield(name))
+      elsif has_default
+        answer = assert_type('Default value', value_type, default_value)
+      else
+        lookup_invocation.emit_debug_info(debug_preamble(names)) if Puppet[:debug]
+        fail_lookup(names)
+      end
+    end
+    lookup_invocation.emit_debug_info(debug_preamble(names)) if Puppet[:debug]
+    answer
+  end
+
+  # @api private
+  def self.debug_preamble(names)
+    if names.size == 1
+      names = "'#{names[0]}'"
+    else
+      names = names.map { |n| "'#{n}'" }.join(', ')
+    end
+    "Lookup of #{names}"
+  end
+
+  # @api private
+  def self.search_and_merge(name, lookup_invocation, merge, apl = true)
+    answer = lookup_invocation.lookup_adapter.lookup(name, lookup_invocation, merge)
+    lookup_invocation.emit_debug_info("Automatic Parameter Lookup of '#{name}'") if apl && Puppet[:debug]
+    answer
+  end
+
+  def self.assert_type(subject, type, value)
+    type ? Types::TypeAsserter.assert_instance_of(subject, type, value) : value
+  end
+  private_class_method :assert_type
+
+  def self.fail_lookup(names)
+    raise Puppet::DataBinding::LookupError,
+          n_("Function lookup() did not find a value for the name '%{name}'",
+             "Function lookup() did not find a value for any of the names [%{name_list}]", names.size
+            ) % { name: names[0], name_list: names.map { |n| "'#{n}'" }.join(', ') }
+  end
+  private_class_method :fail_lookup
+end
+end
+
+require_relative 'lookup/lookup_adapter'

data/vendored/puppet/lib/puppet/pops/lookup/configured_data_provider.rb

@@ -0,0 +1,93 @@
+require_relative 'hiera_config'
+require_relative 'data_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class ConfiguredDataProvider
+  include DataProvider
+
+  # @param config [HieraConfig,nil] the configuration
+  def initialize(config = nil)
+    @config = config.nil? ? nil : assert_config_version(config)
+  end
+
+  def config(lookup_invocation)
+    @config ||= assert_config_version(HieraConfig.create(lookup_invocation, configuration_path(lookup_invocation), self))
+  end
+
+  # Needed to assign generated version 4 config
+  # @deprecated
+  def config=(config)
+    @config = config
+  end
+
+  # @return [Pathname] the path to the configuration
+  def config_path
+    @config.nil? ? nil : @config.config_path
+  end
+
+  # @return [String] the name of this provider
+  def name
+    n = "#{place} "
+    n << '"' << module_name << '" ' unless module_name.nil?
+    n << 'Data Provider'
+    n << " (#{@config.name})" unless @config.nil?
+    n
+  end
+
+  # Performs a lookup by searching all configured locations for the given _key_. A merge will be performed if
+  # the value is found in more than one location.
+  #
+  # @param key [String] 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
+      merge_strategy = MergeStrategy.strategy(merge)
+      dps = data_providers(lookup_invocation)
+      if dps.empty?
+        lookup_invocation.report_not_found(key)
+        throw :no_such_key
+      end
+      merge_strategy.lookup(dps, lookup_invocation) do |data_provider|
+        data_provider.unchecked_key_lookup(key, lookup_invocation, merge_strategy)
+      end
+    end
+  end
+
+  protected
+
+  # Assert that the given config version is accepted by this data provider.
+  #
+  # @param config [HieraConfig] the configuration to check
+  # @return [HieraConfig] the argument
+  # @raise [Puppet::DataBinding::LookupError] if the configuration version is unacceptable
+  def assert_config_version(config)
+    config
+  end
+
+  # Return the root of the configured entity
+  #
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @return [Pathname] Path to root of the module
+  # @raise [Puppet::DataBinding::LookupError] if the given module is can not be found
+  #
+  def provider_root(lookup_invocation)
+    raise NotImplementedError, "#{self.class.name} must implement method '#provider_root'"
+  end
+
+  def configuration_path(lookup_invocation)
+    provider_root(lookup_invocation) + HieraConfig::CONFIG_FILE_NAME
+  end
+
+  private
+
+  def data_providers(lookup_invocation)
+    config(lookup_invocation).configured_data_providers(lookup_invocation, self)
+  end
+end
+end
+end

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

@@ -0,0 +1,200 @@
+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?
+      enumerator = @cache.each_pair
+      @cache.size.times do
+        if block.arity == 2
+          yield(*enumerator.next)
+        else
+          yield(enumerator.next)
+        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/vendored/puppet/lib/puppet/pops/lookup/data_adapter.rb

@@ -0,0 +1,27 @@
+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/vendored/puppet/lib/puppet/pops/lookup/data_dig_function_provider.rb

@@ -0,0 +1,145 @@
+require_relative 'function_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class DataDigFunctionProvider < FunctionProvider
+  TAG = 'data_dig'.freeze
+
+  # 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'.freeze
+
+  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, context = {: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
+      return 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
+    when '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