puppet 4.0.0 → 4.9.1

data/lib/puppet/configurer.rb

@@ -22,6 +22,18 @@ class Puppet::Configurer
     "Puppet configuration client"
   end
 
+  def self.should_pluginsync?
+    if Puppet.settings.set_by_cli?(:pluginsync) || Puppet.settings.set_by_config?(:pluginsync)
+      Puppet[:pluginsync]
+    else
+      if Puppet[:use_cached_catalog]
+        false
+      else
+        true
+      end
+    end
+  end
+
   def execute_postrun_command
     execute_from_setting(:postrun_command)
   end
@@ -44,31 +56,49 @@ class Puppet::Configurer
     end
   end
 
-  def initialize(factory = Puppet::Configurer::DownloaderFactory.new)
-    Puppet.settings.use(:main, :ssl, :agent)
-
+  def initialize(factory = Puppet::Configurer::DownloaderFactory.new, transaction_uuid = nil)
     @running = false
     @splayed = false
+    @cached_catalog_status = 'not_used'
     @environment = Puppet[:environment]
-    @transaction_uuid = SecureRandom.uuid
+    @transaction_uuid = transaction_uuid || SecureRandom.uuid
+    @static_catalog = true
+    @checksum_type = Puppet[:supported_checksum_types]
     @handler = Puppet::Configurer::PluginHandler.new(factory)
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
   def retrieve_catalog(query_options)
     query_options ||= {}
-    # First try it with no cache, then with the cache.
-    unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(query_options)) or result = retrieve_new_catalog(query_options)
-      if ! Puppet[:usecacheonfailure]
-        Puppet.warning "Not using cache on failed catalog"
-        return nil
+    if (Puppet[:use_cached_catalog] && result = retrieve_catalog_from_cache(query_options))
+      @cached_catalog_status = 'explicitly_requested'
+
+      Puppet.info "Using cached catalog from environment '#{result.environment}'"
+    else
+      result = retrieve_new_catalog(query_options)
+
+      if !result
+        if !Puppet[:usecacheonfailure]
+          Puppet.warning "Not using cache on failed catalog"
+          return nil
+        end
+
+        result = retrieve_catalog_from_cache(query_options)
+
+        if result
+          # don't use use cached catalog if it doesn't match server specified environment
+          if @node_environment && result.environment != @environment
+            Puppet.err "Not using cached catalog because its environment '#{result.environment}' does not match '#{@environment}'"
+            return nil
+          end
+
+          @cached_catalog_status = 'on_failure'
+          Puppet.info "Using cached catalog from environment '#{result.environment}'"
+        end
       end
-      result = retrieve_catalog_from_cache(query_options)
     end
 
-    return nil unless result
-
-    convert_catalog(result, @duration)
+    result
   end
 
   # Convert a plain resource catalog into our full host catalog.
@@ -102,25 +132,47 @@ class Puppet::Configurer
   def prepare_and_retrieve_catalog(options, query_options)
     # set report host name now that we have the fact
     options[:report].host = Puppet[:node_name_value]
+    query_options[:transaction_uuid] = @transaction_uuid
+    query_options[:static_catalog] = @static_catalog
+
+    # Query params don't enforce ordered evaluation, so munge this list into a
+    # dot-separated string.
+    query_options[:checksum_type] = @checksum_type.join('.')
+
+    # apply passes in ral catalog
+    catalog = options.delete(:catalog)
+    return catalog if catalog
 
-    unless catalog = (options.delete(:catalog) || retrieve_catalog(query_options))
-      Puppet.err "Could not retrieve catalog; skipping run"
-      return
+    # retrieve_catalog returns json catalog
+    catalog = retrieve_catalog(query_options)
+    return convert_catalog(catalog, @duration) if catalog
+
+    Puppet.err "Could not retrieve catalog; skipping run"
+    nil
+  end
+
+  def prepare_and_retrieve_catalog_from_cache
+    result = retrieve_catalog_from_cache({:transaction_uuid => @transaction_uuid, :static_catalog => @static_catalog})
+    if result
+      Puppet.info "Using cached catalog from environment '#{result.environment}'"
+      return convert_catalog(result, @duration)
     end
-    catalog
+    nil
   end
 
   # Retrieve (optionally) and apply a catalog. If a catalog is passed in
   # the options, then apply that one, otherwise retrieve it.
   def apply_catalog(catalog, options)
     report = options[:report]
-    report.configuration_version = catalog.version
+    begin
+      report.configuration_version = catalog.version
 
-    benchmark(:notice, "Applied catalog") do
-      catalog.apply(options)
+      benchmark(:notice, "Applied catalog") do
+        catalog.apply(options)
+      end
+    ensure
+      report.finalize_report
     end
-
-    report.finalize_report
     report
   end
 
@@ -129,9 +181,45 @@ class Puppet::Configurer
   # which accepts :tags and :ignoreschedules.
   def run(options = {})
     pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
+    # We create the report pre-populated with default settings for
+    # environment and transaction_uuid very early, this is to ensure
+    # they are sent regardless of any catalog compilation failures or
+    # exceptions.
+    options[:report] ||= Puppet::Transaction::Report.new("apply", nil, @environment, @transaction_uuid)
+    report = options[:report]
+    init_storage
+
+    Puppet::Util::Log.newdestination(report)
+
     begin
       Puppet.override(:http_pool => pool) do
-        run_internal(options)
+
+        # Skip failover logic if the server_list setting is empty
+        if Puppet.settings[:server_list].nil? || Puppet.settings[:server_list].empty?
+          do_failover = false;
+        else
+          do_failover = true
+        end
+        # When we are passed a catalog, that means we're in apply
+        # mode. We shouldn't try to do any failover in that case.
+        if options[:catalog].nil? && do_failover
+          found = find_functional_server()
+          server = found[:server]
+          if server.nil?
+            Puppet.warning "Could not select a functional puppet master"
+            server = [nil, nil]
+          end
+          Puppet.override(:server => server[0], :serverport => server[1]) do
+            if !server.first.nil?
+              Puppet.debug "Selected master: #{server[0]}:#{server[1]}"
+              report.master_used = "#{server[0]}:#{server[1]}"
+            end
+
+            run_internal(options.merge(:node => found[:node]))
+          end
+        else
+          run_internal(options)
+        end
       end
     ensure
       pool.close
@@ -139,26 +227,43 @@ class Puppet::Configurer
   end
 
   def run_internal(options)
-    # We create the report pre-populated with default settings for
-    # environment and transaction_uuid very early, this is to ensure
-    # they are sent regardless of any catalog compilation failures or
-    # exceptions.
-    options[:report] ||= Puppet::Transaction::Report.new("apply", nil, @environment, @transaction_uuid)
     report = options[:report]
-    init_storage
 
-    Puppet::Util::Log.newdestination(report)
+    # If a cached catalog is explicitly requested, attempt to retrieve it. Skip the node request,
+    # don't pluginsync and switch to the catalog's environment if we successfully retrieve it.
+    if Puppet[:use_cached_catalog]
+      if catalog = prepare_and_retrieve_catalog_from_cache
+        options[:catalog] = catalog
+        @cached_catalog_status = 'explicitly_requested'
+
+        if @environment != catalog.environment && !Puppet[:strict_environment_mode]
+          Puppet.notice "Local environment: '#{@environment}' doesn't match the environment of the cached catalog '#{catalog.environment}', switching agent to '#{catalog.environment}'."
+          @environment = catalog.environment
+        end
+
+        report.environment = @environment
+      else
+        # Don't try to retrieve a catalog from the cache again after we've already
+        # failed to do so the first time.
+        Puppet[:use_cached_catalog] = false
+        Puppet[:usecacheonfailure] = false
+        options[:pluginsync] = Puppet::Configurer.should_pluginsync?
+      end
+    end
 
     begin
       unless Puppet[:node_name_fact].empty?
         query_options = get_facts(options)
       end
 
+      configured_environment = Puppet[:environment] if Puppet.settings.set_by_config?(:environment)
+
       # We only need to find out the environment to run in if we don't already have a catalog
-      unless options[:catalog]
+      unless (options[:catalog] || Puppet[:strict_environment_mode])
         begin
-          if node = Puppet::Node.indirection.find(Puppet[:node_name_value],
+          if node = options[:node] || Puppet::Node.indirection.find(Puppet[:node_name_value],
               :environment => Puppet::Node::Environment.remote(@environment),
+              :configured_environment => configured_environment,
               :ignore_cache => true,
               :transaction_uuid => @transaction_uuid,
               :fail_on_404 => true)
@@ -169,11 +274,15 @@ class Puppet::Configurer
               node.environment = Puppet::Node::Environment.remote(node.environment_name)
             end
 
+            @node_environment = node.environment.to_s
+
             if node.environment.to_s != @environment
-              Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified node environment \"#{node.environment}\", switching agent to \"#{node.environment}\"."
+              Puppet.notice "Local environment: '#{@environment}' doesn't match server specified node environment '#{node.environment}', switching agent to '#{node.environment}'."
               @environment = node.environment.to_s
               report.environment = @environment
               query_options = nil
+            else
+              Puppet.info "Using configured environment '#{@environment}'"
             end
           end
         rescue StandardError => detail
@@ -195,12 +304,17 @@ class Puppet::Configurer
       Puppet.push_context({:current_environment => local_node_environment}, "Local node environment for configurer transaction")
 
       query_options = get_facts(options) unless query_options
-      query_options[:transaction_uuid] = @transaction_uuid
+      query_options[:configured_environment] = configured_environment
 
       unless catalog = prepare_and_retrieve_catalog(options, query_options)
         return nil
       end
 
+      if Puppet[:strict_environment_mode] && catalog.environment != @environment
+        Puppet.err "Not using catalog because its environment '#{catalog.environment}' does not match agent specified environment '#{@environment}' and strict_environment_mode is set"
+        return nil
+      end
+
       # Here we set the local environment based on what we get from the
       # catalog. Since a change in environment means a change in facts, and
       # facts may be used to determine which catalog we get, we need to
@@ -210,18 +324,22 @@ class Puppet::Configurer
         if tries > 3
           raise Puppet::Error, "Catalog environment didn't stabilize after #{tries} fetches, aborting run"
         end
-        Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified environment \"#{catalog.environment}\", restarting agent run with environment \"#{catalog.environment}\""
+        Puppet.notice "Local environment: '#{@environment}' doesn't match server specified environment '#{catalog.environment}', restarting agent run with environment '#{catalog.environment}'"
         @environment = catalog.environment
         report.environment = @environment
 
         query_options = get_facts(options)
-        query_options[:transaction_uuid] = @transaction_uuid
+        query_options[:configured_environment] = configured_environment
 
         return nil unless catalog = prepare_and_retrieve_catalog(options, query_options)
         tries += 1
       end
 
       execute_prerun_command or return nil
+
+      options[:report].code_id = catalog.code_id
+      options[:report].catalog_uuid = catalog.catalog_uuid
+      options[:report].cached_catalog_status = @cached_catalog_status
       apply_catalog(catalog, options)
       report.exit_status
     rescue => detail
@@ -231,17 +349,42 @@ class Puppet::Configurer
       execute_postrun_command or return nil
     end
   ensure
-    # Between Puppet runs we need to forget the cached values.  This lets us
-    # pick up on new functions installed by gems or new modules being added
-    # without the daemon being restarted.
-    $env_module_directories = nil
-
+    report.cached_catalog_status ||= @cached_catalog_status
     Puppet::Util::Log.close(report)
     send_report(report)
     Puppet.pop_context
   end
   private :run_internal
 
+  def find_functional_server()
+    configured_environment = Puppet[:environment] if Puppet.settings.set_by_config?(:environment)
+
+    node = nil
+    selected_server = Puppet.settings[:server_list].find do |server|
+      # Puppet.override doesn't return the result of its block, so we
+      # need to handle this manually
+      found = false
+      server[1] ||= Puppet[:masterport]
+      Puppet.override(:server => server[0], :serverport => server[1]) do
+        begin
+          node = Puppet::Node.indirection.find(Puppet[:node_name_value],
+              :environment => Puppet::Node::Environment.remote(@environment),
+              :configured_environment => configured_environment,
+              :ignore_cache => true,
+              :transaction_uuid => @transaction_uuid,
+              :fail_on_404 => false)
+          found = true
+        rescue Exception => e
+          # Nothing to see here
+        end
+      end
+      found
+    end
+    { :node => node,
+      :server => selected_server }
+  end
+  private :find_functional_server
+
   def send_report(report)
     puts report.summary if Puppet[:summarize]
     save_last_run_summary(report)
@@ -279,7 +422,6 @@ class Puppet::Configurer
       result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value],
         query_options.merge(:ignore_terminus => true, :environment => Puppet::Node::Environment.remote(@environment)))
     end
-    Puppet.notice "Using cached catalog"
     result
   rescue => detail
     Puppet.log_exception(detail, "Could not retrieve catalog from cache: #{detail}")

data/lib/puppet/context/trusted_information.rb

@@ -17,10 +17,28 @@ class Puppet::Context::TrustedInformation
   # @return [Hash{Object => Object}]
   attr_reader :extensions
 
+  # The domain name derived from the validated certificate name
+  #
+  # @return [String]
+  attr_reader :domain
+
+  # The hostname derived from the validated certificate name
+  #
+  # @return [String]
+  attr_reader :hostname
+
   def initialize(authenticated, certname, extensions)
     @authenticated = authenticated.freeze
     @certname = certname.freeze
     @extensions = extensions.freeze
+    if @certname
+      hostname, domain = @certname.split('.', 2)
+    else
+      hostname = nil
+      domain = nil
+    end
+    @hostname = hostname.freeze
+    @domain = domain.freeze
   end
 
   def self.remote(authenticated, node_name, certificate)
@@ -50,7 +68,9 @@ class Puppet::Context::TrustedInformation
     {
       'authenticated'.freeze => authenticated,
       'certname'.freeze => certname,
-      'extensions'.freeze => extensions
+      'extensions'.freeze => extensions,
+      'hostname'.freeze => hostname,
+      'domain'.freeze => domain,
     }.freeze
   end
 end

data/lib/puppet/context.rb

@@ -20,6 +20,7 @@ class Puppet::Context
   # @api private
   def initialize(initial_bindings)
     @table = initial_bindings
+    @ignores = []
     @description = "root"
     @id = 0
     @rollbacks = {}
@@ -45,7 +46,7 @@ class Puppet::Context
 
   # @api private
   def lookup(name, &block)
-    if @table.include?(name)
+    if @table.include?(name) && !@ignores.include?(name)
       value = @table[name]
       value.is_a?(Proc) ? (@table[name] = value.call) : value
     elsif block
@@ -66,6 +67,20 @@ class Puppet::Context
     rollback(mark_point)
   end
 
+  # @api private
+  def ignore(name)
+    @ignores << name
+  end
+
+  # @api private
+  def restore(name)
+    if @ignores.include?(name)
+      @ignores.delete(name)
+    else
+      raise UndefinedBindingError, "no '#{name}' in ignores #{@ignores.inspect} at top of #{@stack.inspect}"
+    end
+  end
+
   # Mark a place on the context stack to later return to with {rollback}.
   #
   # @param name [Object] The identifier for the mark

data/lib/puppet/daemon.rb

@@ -24,6 +24,7 @@ class Puppet::Daemon
   SIGNAL_CHECK_INTERVAL = 5
 
   attr_accessor :agent, :server, :argv
+  attr_reader :signals
 
   def initialize(pidfile, scheduler = Puppet::Scheduler::Scheduler.new())
     @scheduler = scheduler
@@ -87,12 +88,9 @@ class Puppet::Daemon
 
   def reload
     return unless agent
-    if agent.running?
-      Puppet.notice "Not triggering already-running agent"
-      return
-    end
-
     agent.run({:splay => false})
+  rescue Puppet::LockError
+    Puppet.notice "Not triggering already-running agent"
   end
 
   def restart
@@ -107,13 +105,21 @@ class Puppet::Daemon
   # Trap a couple of the main signals.  This should probably be handled
   # in a way that anyone else can register callbacks for traps, but, eh.
   def set_signal_traps
-    signals = {:INT => :stop, :TERM => :stop }
-    # extended signals not supported under windows
-    signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }) unless Puppet.features.microsoft_windows?
-    signals.each do |signal, method|
+    [:INT, :TERM].each do |signal|
       Signal.trap(signal) do
-        Puppet.notice "Caught #{signal}; storing #{method}"
-        @signals << method
+        Puppet.notice "Caught #{signal}; exiting"
+        stop
+      end
+    end
+
+    # extended signals not supported under windows
+    if !Puppet.features.microsoft_windows?
+      signals = {:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }
+      signals.each do |signal, method|
+        Signal.trap(signal) do
+          Puppet.notice "Caught #{signal}; storing #{method}"
+          @signals << method
+        end
       end
     end
   end
@@ -132,8 +138,6 @@ class Puppet::Daemon
   end
 
   def start
-    set_signal_traps
-
     create_pidfile
 
     raise Puppet::DevError, "Daemons must have an agent, server, or both" unless agent or server

data/lib/puppet/data_binding.rb

@@ -2,11 +2,13 @@ require 'puppet/indirector'
 
 # A class for managing data lookups
 class Puppet::DataBinding
-  class LookupError < Puppet::Error; end
-
   # Set up indirection, so that data can be looked for in the compiler
   extend Puppet::Indirector
 
   indirects(:data_binding, :terminus_setting => :data_binding_terminus,
     :doc => "Where to find external data bindings.")
+
+  class LookupError < Puppet::PreformattedError; end
+
+  class RecursiveLookupError < Puppet::DataBinding::LookupError; end
 end

data/lib/puppet/data_providers/data_adapter.rb

@@ -1,11 +1,22 @@
 # A DataAdapter adapts an object with a Hash of data
 #
+# TODO: API 5.0, remove this class
+# @api private
+# @deprecated
 class Puppet::DataProviders::DataAdapter < Puppet::Pops::Adaptable::Adapter
+  include Puppet::Plugins::DataProviders
+
   attr_accessor :data
-  attr_accessor :env_provider
 
-  def initialize(env)
-    @env = env
+  def self.create_adapter(o)
+    new
+  end
+
+  def initialize
+    unless Puppet[:strict] == :off
+      Puppet.warn_once(:deprecation, 'Puppet::DataProviders::DataAdapter',
+        'Puppet::DataProviders::DataAdapter is deprecated and will be removed in the next major version of Puppet')
+    end
     @data = {}
   end
 
@@ -23,69 +34,4 @@ class Puppet::DataProviders::DataAdapter < Puppet::Pops::Adaptable::Adapter
     end
     @data[name] = value
   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 self.create_adapter(environment)
-    new(environment)
-  end
-
-  def initialize_module_provider(module_name)
-    # Support running tests without an injector being configured == using a null implementation
-    unless injector = Puppet.lookup(:injector) { nil }
-      return Puppet::Plugins::DataProviders::ModuleDataProvider.new()
-    end
-    # Get the registry of module to provider implementation name
-    module_service_type = Puppet::Plugins::DataProviders.hash_of_per_module_data_provider
-    module_service_name = Puppet::Plugins::DataProviders::PER_MODULE_DATA_PROVIDER_KEY
-    module_service = Puppet.lookup(:injector).lookup(nil, module_service_type, module_service_name)
-    provider_name = module_service[module_name] || 'none'
-
-    service_type = Puppet::Plugins::DataProviders.hash_of_module_data_providers
-    service_name = Puppet::Plugins::DataProviders::MODULE_DATA_PROVIDERS_KEY
-
-    # Get the service (registry of known implementations)
-    service = Puppet.lookup(: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
-    # Get the environment's configuration since we need to know which data provider
-    # should be used (includes 'none' which gets a null implementation).
-    #
-    env_conf = Puppet.lookup(:environments).get_conf(@env.name)
-
-    # Get the data provider and find the bound implementation
-    # TODO: PUP-1640, drop the nil check when legacy env support is dropped
-    provider_name = env_conf.nil? ? 'none' : env_conf.environment_data_provider
-    service_type = Puppet::Plugins::DataProviders.hash_of_environment_data_providers
-    service_name = Puppet::Plugins::DataProviders::ENV_DATA_PROVIDERS_KEY
-
-    # Get the service (registry of known implementations)
-    # Support running tests without an injector being configured == using a null implementation
-    unless injector = Puppet.lookup(:injector) { nil }
-      return Puppet::Plugins::DataProviders::EnvironmentDataProvider.new()
-    end
-    service = Puppet.lookup(: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
 end

data/lib/puppet/data_providers/data_function_support.rb

@@ -1,30 +1,17 @@
+# TODO: API 5.0, remove this module
+# @api private
+# @deprecated
 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)
+      unless Puppet[:strict] == :off
+        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::DataFunctionSupport',
+        'Puppet::DataProviders::DataFunctionSupport is deprecated and will be removed in the next major version of Puppet')
+      end
+
+      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 +24,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

@@ -8,20 +8,18 @@ module Puppet::DataProviders; end
 # The function is called on demand, and is associated with the compiler via an Adapter. This ensures that the data
 # is only produced once per compilation.
 #
+# TODO: API 5.0, remove this class
+# @api private
+# @deprecated
 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)
+  def loader(key, scope)
+    unless Puppet[:strict] == :off
+      Puppet.warn_once(:deprecation, 'Puppet::DataProviders::FunctionEnvDataProvider',
+        'Puppet::DataProviders::FunctionEnvDataProvider is deprecated and will be removed in the next major version of Puppet')
     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
   end