puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/configurer/fact_handler.rb

@@ -0,0 +1,37 @@
+require 'puppet/indirector/facts/facter'
+
+require 'puppet/configurer'
+require 'puppet/configurer/downloader'
+
+# Break out the code related to facts.  This module is
+# just included into the agent, but having it here makes it
+# easier to test.
+module Puppet::Configurer::FactHandler
+  def find_facts
+    # This works because puppet agent configures Facts to use 'facter' for
+    # finding facts and the 'rest' terminus for caching them.  Thus, we'll
+    # compile them and then "cache" them on the server.
+    begin
+      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value], :environment => Puppet::Node::Environment.remote(@environment))
+      unless Puppet[:node_name_fact].empty?
+        Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
+        facts.name = Puppet[:node_name_value]
+      end
+      facts
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      message = "Could not retrieve local facts: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message, detail.backtrace
+    end
+  end
+
+  def facts_for_uploading
+    facts = find_facts
+
+    text = facts.render(:pson)
+
+    {:facts_format => :pson, :facts => Puppet::Util.uri_query_encode(text)}
+  end
+end

data/vendor/pup410/lib/puppet/configurer/plugin_handler.rb

@@ -0,0 +1,25 @@
+# Break out the code related to plugins.  This module is
+# just included into the agent, but having it here makes it
+# easier to test.
+require 'puppet/configurer'
+
+class Puppet::Configurer::PluginHandler
+  def initialize(factory)
+    @factory = factory
+  end
+
+  # Retrieve facts from the central server.
+  def download_plugins(environment)
+    plugin_downloader = @factory.create_plugin_downloader(environment)
+
+    result = []
+
+    plugin_fact_downloader = @factory.create_plugin_facts_downloader(environment)
+    result += plugin_fact_downloader.evaluate
+
+    result += plugin_downloader.evaluate
+    Puppet::Util::Autoload.reload_changed
+
+    result
+  end
+end

data/vendor/pup410/lib/puppet/data_providers.rb

@@ -0,0 +1,34 @@
+# TODO: API 5.0, remove this module
+# @api private
+# @deprecated
+module Puppet::DataProviders
+
+  def self.assert_loaded
+    unless @loaded
+      require 'puppet/pops'
+    end
+    @loaded = true
+  end
+
+  # @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
+
+  # @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)
+    unless Puppet[:strict] == :off
+      Puppet.deprecation_warning('The method Puppet::DataProviders.lookup_adapter is deprecated and will be removed in the next major release of Puppet.')
+    end
+    assert_loaded()
+    Puppet::Pops::Lookup::LookupAdapter.adapt(lookup_invocation.scope.compiler)
+  end
+end

data/vendor/pup410/lib/puppet/data_providers/data_adapter.rb

@@ -0,0 +1,37 @@
+# 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
+
+  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
+
+  def [](name)
+    @data[name]
+  end
+
+  def has_name?(name)
+    @data.has_key? name
+  end
+
+  def []=(name, value)
+    unless value.is_a?(Hash)
+      raise ArgumentError, "Given value must be a Hash, got: #{value.class}."
+    end
+    @data[name] = value
+  end
+end

data/vendor/pup410/lib/puppet/data_providers/data_function_support.rb

@@ -0,0 +1,32 @@
+# TODO: API 5.0, remove this module
+# @api private
+# @deprecated
+module Puppet::DataProviders::DataFunctionSupport
+  def initialize_data(data_key, lookup_invocation)
+    name = "#{data_key}::data"
+    scope = lookup_invocation.scope
+    Puppet::Util::Profiler.profile("Called #{name}", [ :functions, name ]) do
+      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
+        #       That can only be done if the function is a puppet function
+        #
+        result = func.call(scope)
+        unless result.is_a?(Hash)
+          raise Puppet::Error.new("Expected '#{name}' function to return a Hash, got #{result.class}")
+        end
+        # validate result if block given
+        result = yield(result) if block_given?
+      else
+        raise Puppet::Error.new("Cannot find the function '#{name}' - required when using 'function' data provider scheme")
+      end
+      result
+    end
+  end
+end

data/vendor/pup410/lib/puppet/data_providers/function_env_data_provider.rb

@@ -0,0 +1,26 @@
+# This file is loaded by the autoloader, and it does not find the data function support unless required relative
+#
+require_relative 'data_function_support'
+module Puppet::DataProviders; end
+
+# The FunctionEnvDataProvider provides data from a function called 'environment::data()' that resides in a
+# directory environment (seen as a module with the name environment).
+# 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 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
+
+    # This loader allows the data function to be private or public in the environment
+    scope.compiler.loaders.private_environment_loader
+  end
+end

data/vendor/pup410/lib/puppet/data_providers/function_module_data_provider.rb

@@ -0,0 +1,24 @@
+# This file is loaded by the autoloader, and it does not find the data function support unless required relative
+#
+require_relative 'data_function_support'
+module Puppet::DataProviders; end
+
+# The FunctionModuleDataProvider provides data from a function called 'environment::data()' that resides in a
+# directory environment (seen as a module with the name environment).
+# 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::FunctionModuleDataProvider < Puppet::Plugins::DataProviders::ModuleDataProvider
+  include Puppet::DataProviders::DataFunctionSupport
+
+  def loader(key, scope)
+    unless Puppet[:strict] == :off
+      Puppet.warn_once(:deprecation, 'Puppet::DataProviders::FunctionModuleDataProvider',
+      'Puppet::DataProviders::FunctionModuleDataProvider is deprecated and will be removed in the next major version of Puppet')
+    end
+    scope.compiler.loaders.private_loader_for_module(key)
+  end
+end

data/vendor/pup410/lib/puppet/data_providers/hiera_config.rb

@@ -0,0 +1,151 @@
+require 'puppet/plugins/data_providers'
+
+# @api private
+module Puppet::DataProviders
+  # TODO: API 5.0, remove this class
+  # @api private
+  # @deprecated
+  class HieraConfig
+    include Puppet::Plugins::DataProviders
+    include Puppet::Pops::Lookup::LocationResolver
+
+    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.config_exist?(config_root)
+      config_path = config_root + 'hiera.yaml'
+      config_path.exist?
+    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.singleton.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)
+      unless Puppet[:strict] == :off
+        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::HieraConfig',
+          "Use of class Puppet::DataProviders::HieraConfig' is deprecated. Puppet::Pops::Lookup::HieraConfig should be used instead", config_path.to_s)
+      end
+      @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)
+      Puppet.deprecation_warning('Method HieraConfig#create_data_providers is deprecated. Use create_configured_data_providers instead')
+      create_configured_data_providers(lookup_invocation, nil)
+    end
+
+    # Creates the data providers for this config
+    #
+    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] Invocation data containing scope, overrides, and defaults
+    # @param parent_data_provider [Puppet::Plugins::DataProviders::DataProvider] The data provider that loaded this configuration
+    # @return [Array[DataProvider]] the created providers
+    #
+    # @api private
+    def create_configured_data_providers(lookup_invocation, parent_data_provider)
+      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, "#{@config_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)}
+        datadir = @config_root + (he['datadir'] || default_datadir)
+        provider_name = he['backend']
+        data_providers[name] = case provider_name
+        when 'json', 'yaml'
+          Puppet::Pops::Lookup::DataHashFunctionProvider.new(name, parent_data_provider, "#{provider_name}_data", {},
+            resolve_paths(datadir, original_paths, lookup_invocation, ".#{provider_name}"))
+        else
+          # TODO: Remove support for injected provider factories
+          paths = original_paths.map { |path| interpolate(path, lookup_invocation, false)}
+          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
+          create_data_provider(parent_data_provider, provider_factory, name, provider_factory.resolve_paths(datadir, original_paths, paths, lookup_invocation))
+        end
+      end
+      data_providers.values
+    end
+
+    def name
+      "hiera version #{version}"
+    end
+
+    def create_data_provider(parent_data_provider, provider_factory, name, resolved_paths)
+      provider_factory_version = provider_factory.respond_to?(:version) ? provider_factory.version : 1
+      if provider_factory_version == 1
+        # Version 1 is not aware of the parent provider
+        provider_factory.create(name, resolved_paths)
+      else
+        provider_factory.create(name, resolved_paths, parent_data_provider)
+      end
+    end
+    private :create_data_provider
+
+    def validate_config(hiera_config)
+      Puppet::Pops::Types::TypeAsserter.assert_instance_of(["The Hiera Configuration at '%s'", @config_path], self.class.config_type, hiera_config)
+    end
+    private :validate_config
+  end
+end

data/vendor/pup410/lib/puppet/data_providers/hiera_env_data_provider.rb

@@ -0,0 +1,25 @@
+# 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
+  # TODO: API 5.0, remove this class
+  # @api private
+  # @deprecated
+  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)
+      unless Puppet[:strict] == :off
+        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::HieraEnvDataProvider',
+        'Puppet::DataProviders::HieraEnvDataProvider is deprecated and will be removed in the next major version of Puppet')
+      end
+      Pathname.new(scope.environment.configuration.path_to_env)
+    end
+    protected :provider_root
+  end
+end

data/vendor/pup410/lib/puppet/data_providers/hiera_interpolate.rb

@@ -0,0 +1,21 @@
+# TODO: API 5.0, remove this module
+# @deprecated Moved to Puppet::Pops::Lookup::Interpolation
+module Puppet::DataProviders::HieraInterpolate
+  include Puppet::Pops::Lookup::Interpolation
+
+  # For backward compatibility
+  # @api private
+  # @deprecated
+  def qualified_lookup(segments, value)
+    if Puppet[:strict] != :off
+      msg = 'Puppet::DataProviders::HieraInterpolate#qualified_lookup is deprecated, use Puppet::Pops::Lookup::SubLookup#sub_lookup'
+      case Puppet[:strict]
+      when :error
+        raise Puppet::DataBinding::LookupError.new(msg)
+      when :warning
+        Puppet.warn_once(:deprecation, 'HieraInterpolate#qualified_lookup', msg)
+      end
+    end
+    sub_lookup('<unknown key>', Puppet::Pops::Lookup::Invocation.current, segments, value)
+  end
+end