puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/pops/binder/config/binder_config.rb

@@ -6,49 +6,31 @@ module Puppet::Pops::Binder::Config
   #
   class BinderConfig
 
-    # The bindings hierarchy is an array of categorizations where the
-    # array for each category has exactly three elements - the categorization name,
-    # category value, and the path that is later used by the backend to read
-    # the bindings for that category
+    # The layering configuration is an array of layers from most to least significant.
+    # Each layer is represented by a Hash containing :name and :include and optionally :exclude
     #
     # @return [Array<Hash<String, String>, Hash<String, Array<String>>]
     # @api public
     #
     attr_reader :layering_config
 
-    # @return [Array<Array(String, String)>] Array of Category tuples where Strings are not evaluated.
-    # @api public
-    #
-    attr_reader :categorization
-
     # @return <Hash<String, String>] ({}) optional mapping of bindings-scheme to handler class name
     attr_reader :scheme_extensions
 
-    # @return <Hash<String, String>] ({}) optional mapping of hiera backend name to backend class name
-    attr_reader :hiera_backends
 
     # @return [String] the loaded config file
     attr_accessor :config_file
 
     DEFAULT_LAYERS = [
-      { 'name' => 'site',    'include' => ['confdir-hiera:/', 'confdir:/default?optional']  },
-      { 'name' => 'modules', 'include' => ['module-hiera:/*/', 'module:/*::default'] },
-    ]
-
-    DEFAULT_CATEGORIES = [
-      ['node',        "${fqdn}"],
-      ['osfamily',    "${osfamily}"],
-      ['environment', "${environment}"],
-      ['common',      "true"]
+      { 'name' => 'site',    'include' => [ 'confdir:/default?optional'] },
+      { 'name' => 'modules', 'include' => [ 'module:/*::default'] },
     ]
 
     DEFAULT_SCHEME_EXTENSIONS = {}
 
-    DEFAULT_HIERA_BACKENDS_EXTENSIONS = {}
-
     def default_config()
       # This is hardcoded now, but may be a user supplied default configuration later
-      {'version' => 1, 'layers' => default_layers, 'categories' => default_categories}
+      {'version' => 1, 'layers' => default_layers }
     end
 
     def confdir()
@@ -72,20 +54,20 @@ module Puppet::Pops::Binder::Config
         rootdir = confdir
         if rootdir.is_a?(String)
           expanded_config_file = File.expand_path(File.join(rootdir, '/binder_config.yaml'))
-          if Puppet::FileSystem::File.exist?(expanded_config_file)
+          if Puppet::FileSystem.exist?(expanded_config_file)
             @config_file = expanded_config_file
           end
         else
           raise ArgumentError, "No Puppet settings 'confdir', or it is not a String"
         end
       when String
-        unless Puppet::FileSystem::File.exist?(@config_file)
+        unless Puppet::FileSystem.exist?(@config_file)
           raise ArgumentError, "Cannot find the given binder configuration file '#{@config_file}'"
         end
       else
         raise ArgumentError, "The setting binder_config is expected to be a String, got: #{@config_file.class.name}."
       end
-      unless @config_file.is_a?(String) && Puppet::FileSystem::File.exist?(@config_file)
+      unless @config_file.is_a?(String) && Puppet::FileSystem.exist?(@config_file)
         @config_file = nil # use defaults
       end
 
@@ -103,14 +85,10 @@ module Puppet::Pops::Binder::Config
 
       unless diagnostics.errors?
         @layering_config   = data['layers'] or default_layers
-        @categorization    = data['categories'] or default_categories
         @scheme_extensions = (data['extensions'] and data['extensions']['scheme_handlers'] or default_scheme_extensions)
-        @hiera_backends    = (data['extensions'] and data['extensions']['hiera_backends'] or default_hiera_backends_extensions)
       else
         @layering_config = []
-        @categorization = {}
         @scheme_extensions = {}
-        @hiera_backends = {}
       end
     end
 
@@ -121,19 +99,9 @@ module Puppet::Pops::Binder::Config
       DEFAULT_LAYERS
     end
 
-    # @api private
-    def default_categories
-      DEFAULT_CATEGORIES
-    end
-
     # @api private
     def default_scheme_extensions
       DEFAULT_SCHEME_EXTENSIONS
     end
-
-    # @api private
-    def default_hiera_backends_extensions
-      DEFAULT_HIERA_BACKENDS_EXTENSIONS
-    end
   end
 end

data/lib/puppet/pops/binder/config/binder_config_checker.rb

@@ -42,12 +42,6 @@ module Puppet::Pops::Binder::Config
         accept(Issues::CONFIG_LAYERS_MISSING, config_file)
       end
 
-      if categories = (data['categories'] || data[:categories])
-        check_categories(categories, config_file)
-      else
-        accept(Issues::CONFIG_CATEGORIES_MISSING, config_file)
-      end
-
       if version = (data['version'] or data[:version])
         accept(Issues::CONFIG_WRONG_VERSION, config_file, {:expected => 1, :actual => version}) unless version == 1
       else
@@ -97,29 +91,6 @@ module Puppet::Pops::Binder::Config
       end
     end
 
-    def check_categories(categories, config_file)
-      unless categories.is_a?(Array)
-        accept(Issues::CATEGORIES_IS_NOT_ARRAY, config_file, :klass => categories.class)
-      else
-        categories.each { |entry| check_category(entry, config_file) }
-      end
-    end
-
-    def check_category(category, config_file)
-      type = @type_calculator.infer(category)
-      unless @type_calculator.assignable?(@array_of_string_type, type)
-        accept(Issues::CATEGORY_IS_NOT_ARRAY, config_file, :type => @type_calculator.string(type))
-        return
-      end
-      unless category.size == 2
-        accept(Issues::CATEGORY_NOT_TWO_STRINGS, config_file, :count => category.size)
-        return
-      end
-      unless category[0] =~ /[a-z][a-zA-Z0-9_]*/
-        accept(Issues::INVALID_CATEGORY_NAME, config_file, :name => category[0])
-      end
-    end
-
     # references to bindings is a single String URI, or an array of String URI
     # @param kind [String] 'include' or 'exclude' (used in issue messages)
     # @param value [String, Array<String>] one or more String URI binding references
@@ -131,12 +102,7 @@ module Puppet::Pops::Binder::Config
       value.each {|ref| check_reference(ref, kind, config_file) }
     end
 
-    # A reference is a URI in string form having one of the schemes:
-    # - module-hiera
-    # - confdir-hiera
-    # - enc
-    #
-    # and with a path (at least '/')
+    # A reference is a URI in string form having a scheme and a path (at least '/')
     #
     def check_reference(value, kind, config_file)
       begin
@@ -161,7 +127,7 @@ module Puppet::Pops::Binder::Config
       end
       # check known extensions
       extensions.each_key do |key|
-        unless ['scheme_handlers', 'hiera_backends'].include? key
+        unless ['scheme_handlers'].include? key
           accept(Issues::UNKNOWN_EXTENSION, config_file, :extension => key)
         end
       end
@@ -171,13 +137,6 @@ module Puppet::Pops::Binder::Config
           accept(Issues::EXTENSION_BINDING_NOT_HASH, config_file, :extension => 'scheme_handlers', :actual => binding_schemes.class.name)
         end
       end
-
-      if hiera_backends = extensions['hiera_backends']
-        unless hiera_backends.is_a?(Hash)
-          accept(Issues::EXTENSION_BINDING_NOT_HASH, config_file, :extension => 'hiera_backends', :actual => hiera_backends.class.name)
-        end
-      end
-
     end
   end
 end

data/lib/puppet/pops/binder/config/issues.rb

@@ -24,30 +24,10 @@ module Puppet::Pops::Binder::Config::Issues
     "The configuration file '#{semantic}' has no 'version' entry in the top level hash"
   end
 
-  CONFIG_CATEGORIES_MISSING = issue :CONFIG_CATEGORIES_MISSING do
-    "The configuration file '#{semantic}' has no 'categories' entry in the top level hash"
-  end
-
   LAYERS_IS_NOT_ARRAY = issue :LAYERS_IS_NOT_ARRAY, :klass do
     "The configuration file '#{semantic}' should contain a 'layers' key with an Array value, got: #{klass.name}"
   end
 
-  CATEGORIES_IS_NOT_ARRAY = issue :CATEGORIES_IS_NOT_ARRAY, :klass do
-    "The configuration file '#{semantic}' should contain a 'categories' key with an Array value, got: #{klass.name}"
-  end
-
-  CATEGORY_IS_NOT_ARRAY = issue :CATEGORY_IS_NOT_ARRAY, :klass do
-    "The configuration file '#{semantic}' each entry in  'categories' should be an Array(String, String), got: #{klass.name}"
-  end
-
-  CATEGORY_NOT_TWO_STRINGS = issue :CATEGORY_NOT_TWO_STRINGS, :count do
-    "The configuration file '#{semantic}' each entry in  'categories' should be an array with 2 strings, got: #{count}"
-  end
-
-  INVALID_CATEGORY_NAME = issue :INVALID_CATEGORY_NAME, :name do
-    "The configuration file '#{semantic}' contains the invalid category: '#{name}', must match /[a-z][a-zA-Z0-9_]*/"
-  end
-
   LAYER_IS_NOT_HASH = issue :LAYER_IS_NOT_HASH, :klass do
     "The configuration file '#{semantic}' should contain one hash per layer, got #{klass.name} instead of Hash"
   end
@@ -100,7 +80,7 @@ module Puppet::Pops::Binder::Config::Issues
     "The configuration file '#{semantic}' contains '#{extension}', expected: Hash, but got: #{actual}."
   end
 
-  UNKNOWN_EXTENSION = issue :UNKNOWN_EXTENSION, :actual do
+  UNKNOWN_EXTENSION = issue :UNKNOWN_EXTENSION, :extension do
     "The configuration file '#{semantic}' contains the unknown extension: #{extension}."
   end
 end

data/lib/puppet/pops/binder/injector.rb

@@ -70,7 +70,7 @@
 #
 # Access to key factory and type calculator
 # -----------------------------------------
-# It is important to use the same key factory, and type calculator as the binder. It is therefor possible to obtaint
+# It is important to use the same key factory, and type calculator as the binder. It is therefor possible to obtain
 # these with the methods {#key_factory}, and {#type_calculator}.
 #
 # Special support for producers
@@ -86,6 +86,73 @@ class Puppet::Pops::Binder::Injector
 
   Producers = Puppet::Pops::Binder::Producers
 
+  def self.create_from_model(layered_bindings_model)
+    self.new(Puppet::Pops::Binder::Binder.new(layered_bindings_model))
+  end
+
+  def self.create_from_hash(name, key_value_hash)
+    factory = Puppet::Pops::Binder::BindingsFactory
+    named_bindings = factory.named_bindings(name) { key_value_hash.each {|k,v| bind.name(k).to(v) }}
+    layered_bindings = factory.layered_bindings(factory.named_layer(name+'-layer',named_bindings.model))
+    self.new(Puppet::Pops::Binder::Binder.new(layered_bindings))
+  end
+
+  # Creates an injector with a single bindings layer created with the given name, and the bindings
+  # produced by the given block. The block is evaluated with self bound to a BindingsContainerBuilder.
+  #
+  # @example
+  #   Injector.create('mysettings') do
+  #     bind('name').to(42)
+  #   end
+  #
+  # @api public
+  #
+  def self.create(name, &block)
+    factory = Puppet::Pops::Binder::BindingsFactory
+    layered_bindings = factory.layered_bindings(factory.named_layer(name+'-layer',factory.named_bindings(name, &block).model))
+    self.new(Puppet::Pops::Binder::Binder.new(layered_bindings))
+  end
+
+  # Creates an overriding injector with a single bindings layer
+  # created with the given name, and the bindings produced by the given block.
+  # The block is evaluated with self bound to a BindingsContainerBuilder.
+  #
+  # @example
+  #   an_injector.override('myoverrides') do
+  #     bind('name').to(43)
+  #   end
+  #
+  # @api public
+  #
+  def override(name, &block)
+    factory = Puppet::Pops::Binder::BindingsFactory
+    layered_bindings = factory.layered_bindings(factory.named_layer(name+'-layer',factory.named_bindings(name, &block).model))
+    self.class.new(Puppet::Pops::Binder::Binder.new(layered_bindings, @impl.binder))
+  end
+
+  # Creates an overriding injector with bindings from a bindings model (a LayeredBindings) which
+  # may consists of multiple layers of bindings.
+  #
+  # @api public
+  #
+  def override_with_model(layered_bindings)
+    unless layered_bindings.is_a?(Puppet::Pops::Binder::Bindings::LayeredBindings)
+      raise ArgumentError, "Expected a LayeredBindings model, got '#{bindings_model.class}'"
+    end
+    self.class.new(Puppet::Pops::Binder::Binder.new(layered_bindings, @impl.binder))
+  end
+
+  # Creates an overriding injector with a single bindings layer
+  # created with the given name, and the bindings given in the key_value_hash
+  # @api public
+  #
+  def override_with_hash(name, key_value_hash)
+    factory = Puppet::Pops::Binder::BindingsFactory
+    named_bindings = factory.named_bindings(name) { key_value_hash.each {|k,v| bind.name(k).to(v) }}
+    layered_bindings = factory.layered_bindings(factory.named_layer(name+'-layer',named_bindings.model))
+    self.class.new(Puppet::Pops::Binder::Binder.new(layered_bindings, @impl.binder))
+  end
+
   # An Injector is initialized with a configured {Puppet::Pops::Binder::Binder Binder}.
   #
   # @param configured_binder [Puppet::Pops::Binder::Binder,nil] The configured binder containing effective bindings. A given value
@@ -94,11 +161,11 @@ class Puppet::Pops::Binder::Injector
   #
   # @api public
   #
-  def initialize(configured_binder)
+  def initialize(configured_binder, parent_injector = nil)
     if configured_binder.nil?
       @impl = Private::NullInjectorImpl.new()
     else
-      @impl = Private::InjectorImpl.new(configured_binder)
+      @impl = Private::InjectorImpl.new(configured_binder, parent_injector)
     end
   end
 
@@ -305,7 +372,11 @@ module Private
       else
         val
       end
+    end
 
+    # @api private
+    def binder
+      nil
     end
 
     # @api private
@@ -345,8 +416,14 @@ module Private
 
     attr_reader :type_calculator
 
-    def initialize(configured_binder)
-      raise ArgumentError, "Given Binder is not configured" unless configured_binder && configured_binder.configured?()
+    attr_reader :binder
+
+    def initialize(configured_binder, parent_injector = nil)
+      @binder = configured_binder
+      @parent = parent_injector
+
+      # TODO: Different error message
+      raise ArgumentError, "Given Binder is not configured" unless configured_binder #&& configured_binder.configured?()
       @entries             = configured_binder.injector_entries()
 
       # It is essential that the injector uses the same key factory as the binder since keys must be
@@ -406,6 +483,7 @@ module Private
     # @api private
     def lookup_type(scope, type, name='')
       val = lookup_key(scope, named_key(type, name))
+      return nil if val.nil?
       unless key_factory.type_calculator.instance?(type, val)
         raise ArgumentError, "Type error: incompatible type, #{type_error_detail(type, val)}"
       end
@@ -427,7 +505,8 @@ module Private
         @recursion_lock.push(key)
         case entry = get_entry(key)
         when NilClass
-          nil
+          @parent ? @parent.lookup_key(scope, key) : nil
+
         when Puppet::Pops::Binder::InjectorEntry
           val = produce(scope, entry)
           return nil if val.nil?
@@ -685,4 +764,4 @@ module Private
     end
   end
 end
-end
+end

data/lib/puppet/pops/binder/injector_entry.rb

@@ -3,7 +3,7 @@
 # @api public
 #
 class Puppet::Pops::Binder::InjectorEntry
-  # @return [Object] An opaque object representing the precedence
+  # @return [Object] An opaque (comparable) object representing the precedence
   # @api public
   attr_reader :precedence
 
@@ -18,7 +18,7 @@ class Puppet::Pops::Binder::InjectorEntry
   attr_accessor :cached_producer
 
   # @api private
-  def initialize(precedence, binding)
+  def initialize(binding, precedence = 0)
     @precedence = precedence.freeze
     @binding = binding
     @cached_producer = nil
@@ -42,6 +42,10 @@ class Puppet::Pops::Binder::InjectorEntry
     binding.abstract
   end
 
+  def is_final?
+    binding.final
+  end
+
   # Compares against another InjectorEntry by comparing precedence.
   # @param injector_entry [InjectorEntry] entry to compare against.
   # @return [Integer] 1, if this entry has higher precedence, 0 if equal, and -1 if given entry has higher precedence.

data/lib/puppet/pops/binder/key_factory.rb

@@ -35,6 +35,12 @@ class Puppet::Pops::Binder::KeyFactory
     "mc_#{multibind_id}"
   end
 
+  # @api public
+  def multibind_contribution_key_to_id(contributions_key)
+    # removes the leading "mc_" from the key to get the multibind_id
+    contributions_key[3..-1]
+  end
+
   # @api public
   def is_named?(key)
     key.is_a?(Array) && key[1] && !key[1].empty?
@@ -58,4 +64,4 @@ class Puppet::Pops::Binder::KeyFactory
     return nil unless key.is_a?(Array)
     key[0]
   end
-end
+end

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

@@ -0,0 +1,191 @@
+# This class is the backing implementation of the Puppet function 'lookup'.
+# See puppet/parser/functions/lookup.rb for documentation.
+#
+class Puppet::Pops::Binder::Lookup
+
+  def self.parse_lookup_args(args)
+    options = {}
+    pblock = if args[-1].respond_to?(:puppet_lambda)
+      args.pop
+    end
+
+    case args.size
+    when 1
+      # name, or all options
+      if args[ 0 ].is_a?(Hash)
+        options = to_symbolic_hash(args[ 0 ])
+      else
+        options[ :name ] = args[ 0 ]
+      end
+
+    when 2
+      # name and type, or name and options
+      if args[ 1 ].is_a?(Hash)
+        options = to_symbolic_hash(args[ 1 ])
+        options[:name] = args[ 0 ] # silently overwrite option with given name
+      else
+        options[:name] = args[ 0 ]
+        options[:type] = args[ 1 ]
+      end
+
+    when 3
+      # name, type, default (no options)
+      options[ :name ] = args[ 0 ]
+      options[ :type ] = args[ 1 ]
+      options[ :default ] = args[ 2 ]
+    else
+      raise Puppet::ParseError, "The lookup function accepts 1-3 arguments, got #{args.size}"
+    end
+    options[:pblock] = pblock
+    options
+  end
+
+  def self.to_symbolic_hash(input)
+    names = [:name, :type, :default, :accept_undef, :extra, :override]
+    options = {}
+    names.each {|n| options[n] = undef_as_nil(input[n.to_s] || input[n]) }
+    options
+  end
+
+  def self.type_mismatch(type_calculator, expected, got)
+    "has wrong type, expected #{type_calculator.string(expected)}, got #{type_calculator.string(got)}"
+  end
+
+  def self.fail(msg)
+    raise Puppet::ParseError, "Function lookup() " + msg
+  end
+
+  def self.fail_lookup(names)
+    name_part = if names.size == 1
+      "the name '#{names[0]}'"
+    else
+      "any of the names ['" + names.join(', ') + "']"
+    end
+    fail("did not find a value for #{name_part}")
+  end
+
+  def self.validate_options(options, type_calculator)
+    type_parser = Puppet::Pops::Types::TypeParser.new
+    name_type = type_parser.parse('Variant[Array[String], String]')
+
+    if is_nil_or_undef?(options[:name]) || options[:name].is_a?(Array) && options[:name].empty?
+      fail ("requires a name, or array of names. Got nothing to lookup.")
+    end
+
+    t = type_calculator.infer(options[:name])
+    if ! type_calculator.assignable?(name_type, t)
+      fail("given 'name' argument, #{type_mismatch(type_calculator, options[:name], t)}")
+    end
+
+    # unless a type is already given (future case), parse the type (or default 'Data'), fails if invalid type is given
+    unless options[:type].is_a?(Puppet::Pops::Types::PAbstractType)
+      options[:type] = type_parser.parse(options[:type] || 'Data')
+    end
+
+    # default value must comply with the given type
+    if options[:default]
+      t = type_calculator.infer(options[:default])
+      if ! type_calculator.assignable?(options[:type], t)
+        fail("'default' value #{type_mismatch(type_calculator, options[:type], t)}")
+      end
+    end
+
+    if options[:extra] && !options[:extra].is_a?(Hash)
+      # do not perform inference here, it is enough to know that it is not a hash
+      fail("'extra' value must be a Hash, got #{options[:extra].class}")
+    end
+    options[:extra] = {} unless options[:extra]
+
+    if options[:override] && !options[:override].is_a?(Hash)
+      # do not perform inference here, it is enough to know that it is not a hash
+      fail("'override' value must be a Hash, got #{options[:extra].class}")
+    end
+    options[:override] = {} unless options[:override]
+
+  end
+
+  def self.nil_as_undef(x)
+    x.nil? ? :undef : x
+  end
+
+  def self.undef_as_nil(x)
+    is_nil_or_undef?(x) ? nil : x
+  end
+
+  def self.is_nil_or_undef?(x)
+    x.nil? || x == :undef
+  end
+
+  # This is used as a marker - a value that cannot (at least not easily) by mistake be found in
+  # hiera data.
+  #
+  class PrivateNotFoundMarker; end
+
+  def self.search_for(scope, type, name, options)
+    # search in order, override, injector, hiera, then extra
+    if !(result = options[:override][name]).nil?
+      result
+    elsif !(result = scope.compiler.injector.lookup(scope, type, name)).nil?
+      result
+   else
+     result = scope.function_hiera([name, PrivateNotFoundMarker])
+     if !result.nil? && result != PrivateNotFoundMarker
+       result
+     else
+       options[:extra][name]
+     end
+   end
+  end
+
+  # This is the method called from the puppet/parser/functions/lookup.rb
+  # @param args [Array] array following the puppet function call conventions
+  def self.lookup(scope, args)
+    type_calculator = Puppet::Pops::Types::TypeCalculator.new
+    options = parse_lookup_args(args)
+    validate_options(options, type_calculator)
+    names = [options[:name]].flatten
+    type = options[:type]
+
+    result_with_name = names.reduce([]) do |memo, name|
+      break memo if !memo[1].nil?
+      [name, search_for(scope, type, name, options)]
+    end
+
+    result = if result_with_name[1].nil?
+      # not found, use default (which may be nil), the default is already type checked
+      options[:default]
+    else
+      # injector.lookup is type-safe already do no need to type check the result
+      result_with_name[1]
+    end
+
+    result = if pblock = options[:pblock]
+      result2 = case pblock.parameter_count
+      when 1
+        pblock.call(scope, nil_as_undef(result))
+      when 2
+        pblock.call(scope, result_with_name[ 0 ], nil_as_undef(result))
+      else
+        pblock.call(scope, result_with_name[ 0 ], nil_as_undef(result), nil_as_undef(options[ :default ]))
+      end
+
+      # if the given result was returned, there is not need to type-check it again
+      if !result2.equal?(result)
+        t = type_calculator.infer(undef_as_nil(result2))
+        if !type_calculator.assignable?(type, t)
+          fail "the value produced by the given code block #{type_mismatch(type_calculator, type, t)}"
+        end
+      end
+      result2
+    else
+      result
+    end
+
+    # Finally, the result if nil must be acceptable or an error is raised
+    if is_nil_or_undef?(result) && !options[:accept_undef]
+      fail_lookup(names)
+    else
+      nil_as_undef(result)
+    end
+  end
+end