puppet 4.2.0 → 4.3.0

data/lib/puppet/data_providers/data_function_support.rb

@@ -1,30 +1,9 @@
 module Puppet::DataProviders::DataFunctionSupport
-  # Gets the data from the compiler, or initializes it from a function call if not present in the compiler.
-  # This means, that the function providing the data is called once per compilation, and the data is cached for
-  # as long as the compiler lives (which is for one catalog production).
-  # This makes it possible to return data that is tailored for the request.
-  # The class including this module must implement `loader(scope)` to return the apropriate loader.
-  #
-  # If a block is given, it will be called to validate the data hash when it is retrieved from a function call. The
-  # block must return the validated data or raise a {Puppet::Error} to indicate that the data is invalid.
-  # The block is not called when the data is found in the compiler or in the cache.
-  #
-  # @param key [String] The data key such as the name of a module or the constant 'environment'
-  # @param scope [Parser::Scope] The scope
-  # @return [Hash] The data hash for the given _key_
-  # @yield An optional block that can be used for validation of the data returned from the function
-  # @yieldparam [Hash] data The data to validate
-  # @yieldreturn [Hash] The validated data
-  #
-  def data(key, scope, &block)
-    compiler = scope.compiler
-    adapter = Puppet::DataProviders::DataAdapter.get(compiler) || Puppet::DataProviders::DataAdapter.adapt(compiler)
-    adapter.data[key] ||= initialize_data_from_function("#{key}::data", key, scope, &block)
-  end
-
-  def initialize_data_from_function(name, key, scope)
+  def initialize_data(data_key, lookup_invocation)
+    name = "#{data_key}::data"
+    scope = lookup_invocation.scope
     Puppet::Util::Profiler.profile("Called #{name}", [ :functions, name ]) do
-      loader = loader(key, scope)
+      loader = loader(data_key, scope)
       if loader && func = loader.load(:function, name)
         # function found, call without arguments, must return a Hash
         # TODO: Validate the function - to ensure it does not contain unwanted side effects
@@ -37,7 +16,7 @@ module Puppet::DataProviders::DataFunctionSupport
         # validate result if block given
         result = yield(result) if block_given?
       else
-        raise Puppet::Error.new("Data from 'function' cannot find the required '#{name}' function")
+        raise Puppet::Error.new("Cannot find the function '#{name}' - required when using 'function' data provider scheme")
       end
       result
     end

data/lib/puppet/data_providers/function_env_data_provider.rb

@@ -11,16 +11,6 @@ module Puppet::DataProviders; end
 class Puppet::DataProviders::FunctionEnvDataProvider < Puppet::Plugins::DataProviders::EnvironmentDataProvider
   include Puppet::DataProviders::DataFunctionSupport
 
-  def lookup(name, scope, merge)
-    begin
-      hash = data('environment', scope)
-      throw :no_such_key unless hash.include?(name)
-      hash[name]
-    rescue *Puppet::Error => detail
-      raise Puppet::DataBinding::LookupError.new(detail.message, detail)
-    end
-  end
-
   def loader(key, scope)
     # This loader allows the data function to be private or public in the environment
     scope.compiler.loaders.private_environment_loader

data/lib/puppet/data_providers/function_module_data_provider.rb

@@ -9,30 +9,8 @@ module Puppet::DataProviders; end
 # is only produced once per compilation.
 #
 class Puppet::DataProviders::FunctionModuleDataProvider < Puppet::Plugins::DataProviders::ModuleDataProvider
-  MODULE_NAME = 'module_name'.freeze
   include Puppet::DataProviders::DataFunctionSupport
 
-  def lookup(name, scope, merge)
-    # Do not attempt to do a lookup in a module unless the name is qualified.
-    qual_index = name.index('::')
-    throw :no_such_key if qual_index.nil?
-    module_name = name[0..qual_index-1]
-    begin
-      hash = data(module_name, scope) do | data |
-        module_prefix = "#{module_name}::"
-        data.each_pair do |k,v|
-          unless k.is_a?(String) && k.start_with?(module_prefix)
-            raise Puppet::Error, "Module data for module '#{module_name}' must use keys qualified with the name of the module"
-          end
-        end
-      end
-      throw :no_such_key unless hash.include?(name)
-      hash[name]
-    rescue *Puppet::Error => detail
-      raise Puppet::DataBinding::LookupError.new(detail.message, detail)
-    end
-  end
-
   def loader(key, scope)
     scope.compiler.loaders.private_loader_for_module(key)
   end

data/lib/puppet/data_providers/hiera_config.rb

@@ -0,0 +1,106 @@
+require 'pathname'
+require_relative 'hiera_interpolate'
+
+module Puppet::DataProviders
+  class HieraConfig
+    include Puppet::Plugins::DataProviders
+    include HieraInterpolate
+
+    DEFAULT_CONFIG = {
+      'version' => 4,
+      'datadir' => 'data',
+      'hierarchy' => [
+        {
+          'name' => 'common',
+          'backend' => 'yaml'
+        }
+      ]
+    }.freeze
+
+    def self.config_type
+      @@CONFIG_TYPE ||= create_config_type
+    end
+
+    def self.symkeys_to_string(struct)
+      case(struct)
+      when Hash
+        Hash[struct.map { |k,v| [k.to_s, symkeys_to_string(v)] }]
+      when Array
+        struct.map { |v| symkeys_to_string(v) }
+      else
+        struct
+      end
+    end
+
+    def self.create_config_type
+      hierarchy_elem_type_base = 'Struct[{'\
+        'backend=>String[1],'\
+        'name=>String[1],'\
+        'datadir=>Optional[String[1]]'
+
+      hierarchy_elem_type_v1 = hierarchy_elem_type_base + ',path=>String[1]}]'
+      hierarchy_elem_type_v2 = hierarchy_elem_type_base + ',paths=>Array[String[1]]}]'
+      hierarchy_elem_type_v3 = hierarchy_elem_type_base + '}]'
+
+      Puppet::Pops::Types::TypeParser.new.parse('Struct[{'\
+        'version=>Integer[4],'\
+        "hierarchy=>Optional[Array[Variant[#{hierarchy_elem_type_v1},#{hierarchy_elem_type_v2},#{hierarchy_elem_type_v3}]]],"\
+        'datadir=>Optional[String[1]]}]')
+    end
+    private_class_method :create_config_type
+
+    attr_reader :config_path, :version
+
+    # Creates a new HieraConfig from the given _config_root_. This is where the 'hiera.yaml' is expected to be found
+    # and is also the base location used when resolving relative paths.
+    #
+    # @param config_root [Pathname] Absolute path to the configuration root
+    # @api public
+    def initialize(config_root)
+      @config_root = config_root
+      @config_path = config_root + 'hiera.yaml'
+      if @config_path.exist?
+        @config = validate_config(HieraConfig.symkeys_to_string(YAML.load_file(@config_path)))
+        @config['hierarchy'] ||= DEFAULT_CONFIG['hierarchy']
+        @config['datadir'] ||= DEFAULT_CONFIG['datadir']
+      else
+        @config = DEFAULT_CONFIG
+      end
+      @version = @config['version']
+    end
+
+    def create_data_providers(lookup_invocation)
+      injector = Puppet.lookup(:injector)
+      service_type = Registry.hash_of_path_based_data_provider_factories
+      default_datadir = @config['datadir']
+
+      # Hashes enumerate their values in the order that the corresponding keys were inserted so it's safe to use
+      # a hash for the data_providers.
+      data_providers = {}
+      @config['hierarchy'].each do |he|
+        name = he['name']
+        raise Puppet::DataBinding::LookupError, "#{path}: Name '#{name}' defined more than once" if data_providers.include?(name)
+        original_paths = he['paths']
+        if original_paths.nil?
+          single_path = he['path']
+          single_path = name if single_path.nil?
+          original_paths = [single_path]
+        end
+        paths = original_paths.map { |path| interpolate(path, lookup_invocation, false)}
+        provider_name = he['backend']
+        provider_factory = injector.lookup(nil, service_type, PATH_BASED_DATA_PROVIDER_FACTORIES_KEY)[provider_name]
+        raise Puppet::DataBinding::LookupError, "#{@config_path}: No data provider is registered for backend '#{provider_name}' " unless provider_factory
+
+        datadir = @config_root + (he['datadir'] || default_datadir)
+        resolved_paths = provider_factory.resolve_paths(datadir, original_paths, paths, lookup_invocation)
+        data_providers[name] = provider_factory.create(name, resolved_paths)
+      end
+      data_providers.values
+    end
+
+    def validate_config(hiera_config)
+      Puppet::Pops::Types::TypeAsserter.assert_instance_of(@config_path, self.class.config_type, hiera_config)
+    end
+    private :validate_config
+  end
+end

data/lib/puppet/data_providers/hiera_env_data_provider.rb

@@ -0,0 +1,18 @@
+# This file is loaded by the autoloader, and it does not find the hiera support unless required relative
+require_relative 'hiera_support'
+
+module Puppet::DataProviders
+  class HieraEnvDataProvider < Puppet::Plugins::DataProviders::EnvironmentDataProvider
+    include HieraSupport
+
+    # Return the root of the environment found in the given _scope_
+    #
+    # @param data_key [String] not used
+    # @param scope [Puppet::Parser::Scope] the parser scope where the environment is found
+    # @return [Pathname] Path to root of the environment
+    def provider_root(_, scope)
+      Pathname.new(scope.environment.configuration.path_to_env)
+    end
+    protected :provider_root
+  end
+end

data/lib/puppet/data_providers/hiera_interpolate.rb

@@ -0,0 +1,97 @@
+require_relative 'hiera_config'
+
+# Add support for Hiera-like interpolation expressions. The expressions may contain keys that uses dot-notation
+# to further navigate into hashes and arrays
+#
+module Puppet::DataProviders::HieraInterpolate
+  def interpolate(subject, lookup_invocation, allow_methods)
+    return subject unless subject.is_a?(String) && !subject.index('%{').nil?
+
+    lookup_invocation.with(:interpolate, subject) do
+      subject.gsub(/%\{([^\}]+)\}/) do |match|
+        method_key, key = get_method_and_data($1, allow_methods)
+        is_alias = method_key == 'alias'
+
+        # Alias is only permitted if the entire string is equal to the interpolate expression
+        raise Puppet::DataBinding::LookupError, "'alias' interpolation is only permitted if the expression is equal to the entire string" if is_alias && subject != match
+
+        segments = key.split('.')
+        value = interpolate_method(method_key).call(segments[0], lookup_invocation)
+        value = qualified_lookup(segments.drop(1), value) if segments.size > 1
+        value = lookup_invocation.check(key) { interpolate(value, lookup_invocation, allow_methods) } if value.is_a?(String)
+
+        # break gsub and return value immediately if this was an alias substitution. The value might be something other than a String
+        return value if is_alias
+
+        value || ''
+      end
+    end
+  end
+
+  private
+
+  def interpolate_method(method_key)
+    @@interpolate_methods ||= begin
+      global_lookup = lambda { |key, lookup_invocation| Puppet::Pops::Lookup.lookup(key, nil, '', true, nil, lookup_invocation) }
+      scope_lookup = lambda do |key, lookup_invocation|
+        lookup_invocation.with(:scope, nil) do
+          ovr = lookup_invocation.override_values
+          if ovr.include?(key)
+            lookup_invocation.report_found_in_overrides(key, ovr[key])
+          else
+            scope = lookup_invocation.scope
+            if scope.include?(key)
+              lookup_invocation.report_found(key, scope[key])
+            else
+              defaults = lookup_invocation.default_values
+              if defaults.include?(key)
+                lookup_invocation.report_found_in_defaults(key, defaults[key])
+              else
+                nil
+              end
+            end
+          end
+        end
+      end
+
+
+      {
+        'lookup' => global_lookup,
+        'hiera' => global_lookup, # this is just an alias for 'lookup'
+        'alias' => global_lookup, # same as 'lookup' but expression must be entire string. The result that is not subject to string substitution
+        'scope' => scope_lookup,
+        'literal' => lambda { |key, _| key }
+      }
+    end
+    interpolate_method = @@interpolate_methods[method_key]
+    raise Puppet::DataBinding::LookupError, "Unknown interpolation method '#{method_key}'" unless interpolate_method
+    interpolate_method
+  end
+
+  def qualified_lookup(segments, value)
+    segments.each do |segment|
+      throw :no_such_key if value.nil?
+      if segment =~ /^[0-9]+$/
+        segment = segment.to_i
+        raise Puppet::DataBinding::LookupError, "Data provider type mismatch: Got #{value.class.name} when Array was expected to enable lookup using key '#{segment}'" unless value.instance_of?(Array)
+        throw :no_such_key unless segment < value.size
+      else
+        raise Puppet::DataBinding::LookupError, "Data provider type mismatch: Got #{value.class.name} when a non Array object that responds to '[]' was expected to enable lookup using key '#{segment}'" unless value.respond_to?(:'[]') && !value.instance_of?(Array)
+        throw :no_such_key unless value.include?(segment)
+      end
+      value = value[segment]
+    end
+    value
+  end
+
+  def get_method_and_data(data, allow_methods)
+    if match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
+      raise Puppet::DataBinding::LoookupError, 'Interpolation using method syntax is not allowed in this context' unless allow_methods
+      key = match[1]
+      data = match[2] || match[3] # double or single qouted
+    else
+      key = 'scope'
+    end
+    [key, data]
+  end
+end

data/lib/puppet/data_providers/hiera_module_data_provider.rb

@@ -0,0 +1,23 @@
+# This file is loaded by the autoloader, and it does not find the hiera support unless required relative
+require_relative 'hiera_support'
+
+module Puppet::DataProviders
+  class HieraModuleDataProvider < Puppet::Plugins::DataProviders::ModuleDataProvider
+    include HieraSupport
+
+    # Return the root of the module with the name equal to _data_key_ found in the environment of the given _scope_
+    #
+    # @param data_key [String] the name of the module
+    # @param scope [Puppet::Parser::Scope] the parser scope where the environment is found
+    # @return [Pathname] Path to root of the environment
+    # @raise [Puppet::DataBinder::LookupError] if the given module is can not be found
+    #
+    def provider_root(module_name, scope)
+      env = scope.environment
+      mod = env.modules.find { |m| m.name == module_name }
+      raise Puppet::DataBinder::LookupError, "Environment '#{env.name}', cannot find module '#{module_name}'" unless mod
+      Pathname.new(mod.path)
+    end
+    protected :provider_root
+  end
+end

data/lib/puppet/data_providers/hiera_support.rb

@@ -0,0 +1,37 @@
+require_relative 'hiera_config'
+
+module Puppet::DataProviders::HieraSupport
+  def config_path
+    @hiera_config.nil? ? 'not yet configured' : @hiera_config.config_path
+  end
+
+  def name
+    'Hiera Data Provider' + (@hiera_config.nil? ? '' : ", version #{@hiera_config.version}")
+  end
+
+  # Performs a lookup by searching all given paths for the given _key_. A merge will be performed if
+  # the value is found in more than one location and _merge_ is not nil.
+  #
+  # @param key [String] The key to lookup
+  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
+  # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  #
+  # @api public
+  def unchecked_lookup(key, lookup_invocation, merge)
+    lookup_invocation.with(:data_provider, self) do
+      merge_strategy = Puppet::Pops::MergeStrategy.strategy(merge)
+      lookup_invocation.with(:merge, merge_strategy) do
+        merged_result = merge_strategy.merge_lookup(data_providers(data_key(key, lookup_invocation), lookup_invocation)) do |data_provider|
+          data_provider.unchecked_lookup(key, lookup_invocation, merge_strategy)
+        end
+        lookup_invocation.report_result(merged_result)
+      end
+    end
+  end
+
+  def data_providers(data_key, lookup_invocation)
+    @hiera_config ||= Puppet::DataProviders::HieraConfig.new(provider_root(data_key, lookup_invocation.scope))
+    @data_providers ||= @hiera_config.create_data_providers(lookup_invocation)
+  end
+  private :data_providers
+end

data/lib/puppet/data_providers/json_data_provider_factory.rb

@@ -0,0 +1,31 @@
+# This file is loaded by the autoloader, and it does not find the data function support unless required relative
+#
+require 'json'
+require_relative 'hiera_interpolate'
+
+module Puppet::DataProviders
+  class JsonDataProviderFactory < Puppet::Plugins::DataProviders::FileBasedDataProviderFactory
+    def create(name, paths)
+      JsonDataProvider.new(name, paths)
+    end
+
+    def path_extension
+      '.json'
+    end
+  end
+
+  class JsonDataProvider < Puppet::Plugins::DataProviders::PathBasedDataProvider
+    include HieraInterpolate
+
+    def initialize_data(path, lookup_invocation)
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError => ex
+      # Filename not included in message, so we add it here.
+      raise Puppet::DataBinding::LookupError, "Unable to parse (#{path}): #{ex.message}"
+    end
+
+    def post_process(value, lookup_invocation)
+      interpolate(value, lookup_invocation, true)
+    end
+  end
+end

data/lib/puppet/data_providers/lookup_adapter.rb

@@ -0,0 +1,200 @@
+# A LookupAdapter is a specialized DataAdapter that uses its hash to store module providers. It also remembers the environment
+# that it is attached to and maintains a cache of _lookup options_ retrieved from its data providers.
+#
+class Puppet::DataProviders::LookupAdapter < Puppet::DataProviders::DataAdapter
+
+  LOOKUP_OPTIONS = 'lookup_options'.freeze
+  HASH = 'hash'.freeze
+  MERGE = 'merge'.freeze
+
+  def self.create_adapter(env)
+    new(env)
+  end
+
+  def initialize(env)
+    super()
+    @env = env
+    @lookup_options = {}
+  end
+
+  # Performs a lookup using global, environment, and module data providers. Merge the result using the given
+  # _merge_ strategy. If the merge strategy is nil, then an attempt is made to find merge options in the
+  # `lookup_options` hash for an entry associated with the key. If no options are found, the no merge is performed
+  # and the first found entry is returned.
+  #
+  # @param key [String] The key to lookup
+  # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] Invocation data containing scope, overrides, and defaults
+  # @return [Object] The found value
+  # @throws :no_such_key if the given key is not found
+  #
+  def lookup(key, lookup_invocation, merge)
+    merge = lookup_merge_options(key, lookup_invocation) if merge.nil?
+    merge_strategy = Puppet::Pops::MergeStrategy.strategy(merge)
+    lookup_invocation.with(:merge, merge_strategy) do
+      result = merge_strategy.merge_lookup([:lookup_global, :lookup_in_environment, :lookup_in_module]) { |m| send(m, key, lookup_invocation, merge_strategy) }
+      lookup_invocation.report_result(result)
+      result
+    end
+  end
+
+  # @api private
+  def lookup_global(name, lookup_invocation, merge_strategy)
+    terminus = Puppet[:data_binding_terminus]
+    lookup_invocation.with(:global, terminus) do
+      catch(:no_such_key) do
+        return lookup_invocation.report_found(name, Puppet::DataBinding.indirection.find(name,
+            { :environment => @env.to_s, :variables => lookup_invocation.scope, :merge => merge_strategy }))
+      end
+      lookup_invocation.report_not_found(name)
+      throw :no_such_key
+    end
+  rescue Puppet::DataBinding::LookupError => e
+    raise Puppet::Error.new("Error from DataBinding '#{terminus}' while looking up '#{name}': #{e.message}", e)
+  end
+
+  # @api private
+  def lookup_in_environment(name, lookup_invocation, merge_strategy)
+    env_provider.lookup(name, lookup_invocation, merge_strategy)
+  end
+
+  # @api private
+  def lookup_in_module(name, lookup_invocation, merge_strategy)
+    module_name = extract_module_name(name)
+
+    # Do not attempt to do a lookup in a module unless the name is qualified.
+    throw :no_such_key if module_name.nil?
+
+    lookup_invocation.with(:module, module_name) do
+      if @env.module(module_name).nil?
+        lookup_invocation.report_module_not_found
+        throw :no_such_key
+      end
+      module_provider(module_name).lookup(name, lookup_invocation, merge_strategy)
+    end
+  end
+
+  # Retrieve the merge options that match the given `name`.
+  #
+  # @param name [String] The key for which we want merge options
+  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] the lookup invocation
+  # @return [String,Hash,nil] The found merge options or nil
+  #
+  def lookup_merge_options(name, lookup_invocation)
+    lookup_options = lookup_lookup_options(name, lookup_invocation)
+    lookup_options.nil? ? nil : lookup_options[MERGE]
+  end
+
+  # Retrieve the lookup options that match the given `name`.
+  #
+  # @param name [String] The key for which we want lookup options
+  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] the lookup invocation
+  # @return [String,Hash,nil] The found lookup options or nil
+  #
+  def lookup_lookup_options(name, lookup_invocation)
+    module_name = extract_module_name(name)
+
+    # Retrieve the options for the module. We use nil as a key in case we have none
+    options = @lookup_options[module_name]
+    if options.nil? && !@lookup_options.include?(module_name)
+      options = retrieve_lookup_options(module_name, lookup_invocation, Puppet::Pops::MergeStrategy.strategy(HASH))
+      raise Puppet::DataBinding::LookupError.new("value of #{LOOKUP_OPTIONS} must be a hash") unless options.nil? || options.is_a?(Hash)
+      @lookup_options[module_name] = options
+    end
+    options.nil? ? nil : options[name]
+  end
+
+  private
+
+  # Retrieve lookup options that applies when using a specific module (i.e. a merge of the pre-cached
+  # `env_lookup_options` and the module specific data)
+  def retrieve_lookup_options(module_name, lookup_invocation, merge_strategy)
+    lookup_invocation.with(:meta, module_name) do
+      env_opts = env_lookup_options(lookup_invocation, merge_strategy)
+      options = nil
+      unless module_name.nil?
+        catch(:no_such_key) do
+          options = module_provider(module_name).lookup(LOOKUP_OPTIONS, lookup_invocation, merge_strategy)
+          options = merge_strategy.merge(env_opts, options) unless env_opts.nil?
+        end
+      end
+      options.nil? ? env_opts : options
+    end
+  end
+
+  # Retrieve and cache lookup options specific to the environment that this adapter is attached to (i.e. a merge
+  # of global and environment lookup options).
+  def env_lookup_options(lookup_invocation, merge_strategy)
+    unless instance_variable_defined?(:@env_lookup_options)
+      @env_lookup_options = nil
+      catch(:no_such_key) do
+        @env_lookup_options = merge_strategy.merge_lookup([:lookup_global, :lookup_in_environment]) do |m|
+          send(m, LOOKUP_OPTIONS, lookup_invocation, merge_strategy)
+        end
+      end
+    end
+    @env_lookup_options
+  end
+
+  def env_provider
+    @env_provider ||= initialize_env_provider
+  end
+
+  def module_provider(module_name)
+    # Test if the key is present for the given module_name. It might be there even if the
+    # value is nil (which indicates that no module provider is configured for the given name)
+    unless data.include?(module_name)
+      data[module_name] = initialize_module_provider(module_name)
+    end
+    data[module_name]
+  end
+
+  def initialize_module_provider(module_name)
+    injector = Puppet.lookup(:injector) { nil }
+
+    # Support running tests without an injector being configured == using a null implementation
+    return ModuleDataProvider.new() unless injector
+
+    # Get the registry of module to provider implementation name
+    module_service_type = Registry.hash_of_per_module_data_provider
+    module_service_name = PER_MODULE_DATA_PROVIDER_KEY
+    module_service = injector.lookup(nil, module_service_type, module_service_name)
+    provider_name = module_service[module_name] || 'none'
+
+    service_type = Registry.hash_of_module_data_providers
+    service_name = MODULE_DATA_PROVIDERS_KEY
+
+    # Get the service (registry of known implementations)
+    service = injector.lookup(nil, service_type, service_name)
+    provider = service[provider_name]
+    unless provider
+      raise Puppet::Error.new("Environment '#{@env.name}', cannot find module_data_provider '#{provider_name}'")
+    end
+    provider
+  end
+
+  def initialize_env_provider
+    injector = Puppet.lookup(:injector) { nil }
+
+    # Support running tests without an injector being configured == using a null implementation
+    return EnvironmentDataProvider.new() unless injector
+
+    # Get the name of the data provider from the environment's configuration and find the bound implementation
+    provider_name = @env.configuration.environment_data_provider
+    service_type = Registry.hash_of_environment_data_providers
+    service_name = ENV_DATA_PROVIDERS_KEY
+
+    # Get the service (registry of known implementations)
+    service = injector.lookup(nil, service_type, service_name)
+    provider = service[provider_name]
+    unless provider
+      raise Puppet::Error.new("Environment '#{@env.name}', cannot find environment_data_provider '#{provider_name}'")
+    end
+    provider
+  end
+
+  def extract_module_name(name)
+    qual_index = name.index('::')
+    qual_index.nil? ? nil : name[0..qual_index-1]
+  end
+end

data/lib/puppet/data_providers/yaml_data_provider_factory.rb

@@ -0,0 +1,32 @@
+# This file is loaded by the autoloader, and it does not find the data function support unless required relative
+#
+require 'yaml'
+require_relative 'hiera_interpolate'
+
+module Puppet::DataProviders
+  class YamlDataProviderFactory < Puppet::Plugins::DataProviders::FileBasedDataProviderFactory
+    def create(name, paths)
+      YamlDataProvider.new(name, paths)
+    end
+
+    def path_extension
+      '.yaml'
+    end
+  end
+
+  class YamlDataProvider < Puppet::Plugins::DataProviders::PathBasedDataProvider
+    include HieraInterpolate
+
+    def initialize_data(path, lookup_invocation)
+      HieraConfig.symkeys_to_string(YAML.load_file(path))
+    rescue YAML::SyntaxError => ex
+      # Psych errors includes the absolute path to the file, so no need to add that
+      # to the message
+      raise Puppet::DataBinding::LookupError, "Unable to parse #{ex.message}"
+    end
+
+    def post_process(value, lookup_invocation)
+      interpolate(value, lookup_invocation, true)
+    end
+  end
+end