puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

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/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.rb

@@ -4,28 +4,27 @@ module Puppet::DataProviders
     unless @loaded
       require 'puppet/pops'
       require 'puppet/data_providers/data_adapter'
+      require 'puppet/data_providers/lookup_adapter'
     end
     @loaded = true
   end
 
-  def self.lookup_in_environment(name, scope, merge)
-    assert_loaded()
-    adapter = Puppet::DataProviders::DataAdapter.adapt(Puppet.lookup(:current_environment))
-    adapter.env_provider.lookup(name, scope, merge)
+  # @deprecated use `lookup_adapter(lookup_invocation).lookup` instead
+  def self.lookup_in_environment(name, lookup_invocation, merge)
+    Puppet.deprecation_warning('The method Puppet::DataProviders.lookup_in_environment is deprecated and will be removed in the next major release of Puppet.')
+    lookup_adapter(lookup_invocation).lookup_in_environment(name, lookup_invocation, Puppet::Pops::MergeStrategy.strategy(merge))
   end
 
   MODULE_NAME = 'module_name'.freeze
 
-  def self.lookup_in_module(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]
+  # @deprecated use `adapter(lookup_invocation).lookup` instead
+  def self.lookup_in_module(name, lookup_invocation, merge)
+    Puppet.deprecation_warning('The method Puppet::DataProviders.lookup_in_module is deprecated and will be removed in the next major release of Puppet.')
+    lookup_adapter(lookup_invocation).lookup_in_module(name, lookup_invocation, Puppet::Pops::MergeStrategy.strategy(merge))
+  end
 
+  def self.lookup_adapter(lookup_invocation)
     assert_loaded()
-    adapter = Puppet::DataProviders::DataAdapter.adapt(Puppet.lookup(:current_environment))
-    data_provider = adapter.module_provider(module_name)
-    throw :no_such_key if data_provider.nil?
-    data_provider.lookup(name, scope, merge)
+    LookupAdapter.adapt(lookup_invocation.scope.environment)
   end
 end

data/lib/puppet/data_providers/data_adapter.rb

@@ -1,11 +1,15 @@
 # A DataAdapter adapts an object with a Hash of data
 #
 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
     @data = {}
   end
 
@@ -23,69 +27,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,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