puppet 3.4.3 → 3.5.0.rc1

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

@@ -104,16 +104,6 @@ module Puppet::Pops::Binder::BinderIssues
     "#{label.a_an_uc(semantic)} has zero predicates"
   end
 
-  # @api public
-  MISSING_CATEGORIZATION = issue :MISSING_CATEGORIZATION do
-    "#{label.a_an_uc(semantic)} has a category without categorization"
-  end
-
-  # @api public
-  MISSING_CATEGORY_VALUE = issue :MISSING_CATEGORY_VALUE do
-    "#{label.a_an_uc(semantic)} has a category without value"
-  end
-
   # @api public
   MISSING_LAYERS = issue :MISSING_LAYERS do
     "#{label.a_an_uc(semantic)} has zero layers"
@@ -129,14 +119,4 @@ module Puppet::Pops::Binder::BinderIssues
     "#{label.a_an_uc(semantic)} has zero bindings in #{label.label(layer)}"
   end
 
-  # @api public
-  PRECEDENCE_MISMATCH_IN_CONTRIBUTION = issue :PRECEDENCE_MISMATCH_IN_CONTRIBUTION, :categorization do
-    "Precedence mismatch: binding contribution '#{semantic.name}', category: '#{categorization}' is not in correct order"
-  end
-
-  # @api public
-  MISSING_CATEGORY_PRECEDENCE = issue :MISSING_CATEGORY_PRECEDENCE, :categorization do
-    "Missing category precedence: binding contribution '#{semantic.name}', category: '#{categorization}' not found in overall config"
-  end
-
-end
+end

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

@@ -71,30 +71,10 @@ class Puppet::Pops::Binder::BindingsChecker
     check_Bindings(b)
   end
 
-  # Check that the category has a categorization and a value
-  # @api private
-  def check_Category(c)
-    acceptor.accept(Issues::MISSING_CATEGORIZATION, binding_parent(c)) unless has_chars?(c.categorization)
-    acceptor.accept(Issues::MISSING_CATEGORY_VALUE, binding_parent(c)) unless has_chars?(c.value)
-  end
-
-  # Check that the binding contains at least one predicate and that all predicates are categorized and has a value
-  # @api private
-  def check_CategorizedBindings(b)
-    acceptor.accept(Issues::MISSING_PREDICATES, b) unless has_entries?(b.predicates)
-    check_Bindings(b)
-  end
-
-  # @api private
-  def check_EffectiveCategories(ec)
-  end
-
   # Check layer has a name
   # @api private
   def check_NamedLayer(l)
     acceptor.accept(Issues::MISSING_LAYER_NAME, binding_parent(l)) unless has_chars?(l.name)
-# It is ok to have an empty layer
-#    acceptor.accept(Issues::MISSING_BINDINGS_IN_LAYER, binding_parent(l), { :layer => l.name }) unless has_entries?(l.bindings)
   end
 
   # Checks that the binding has layers and that each layer has a name and at least one binding

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

@@ -62,30 +62,19 @@ class Puppet::Pops::Binder::BindingsComposer
     # get extensions from the config
     # ------------------------------
     scheme_extensions = @config.scheme_extensions
-    hiera_backends = @config.hiera_backends
 
     # Define a named bindings that are known by the SystemBindings
     boot_bindings = Puppet::Pops::Binder::BindingsFactory.named_bindings(Puppet::Pops::Binder::SystemBindings::ENVIRONMENT_BOOT_BINDINGS_NAME) do
       scheme_extensions.each_pair do |scheme, class_name|
         # turn each scheme => class_name into a binding (contribute to the buildings-schemes multibind).
         # do this in category 'extensions' to allow them to override the 'default'
-        when_in_category('extension', 'true').bind do
+        bind do
           name(scheme)
-          instance_of(Puppetx::BINDINGS_SCHEMES_TYPE)
-          in_multibind(Puppetx::BINDINGS_SCHEMES)
+          instance_of(::Puppetx::BINDINGS_SCHEMES_TYPE)
+          in_multibind(::Puppetx::BINDINGS_SCHEMES)
           to_instance(class_name)
           end
       end
-      hiera_backends.each_pair do |symbolic, class_name|
-        # turn each symbolic => class_name into a binding (contribute to the hiera backends multibind).
-        # do this in category 'extensions' to allow them to override the 'default'
-        when_in_category('extension', 'true').bind do
-          name(symbolic)
-          instance_of(Puppetx::HIERA2_BACKENDS_TYPE)
-          in_multibind(Puppetx::HIERA2_BACKENDS)
-          to_instance(class_name)
-        end
-      end
     end
 
     @injector = scope.compiler.create_boot_injector(boot_bindings.model)
@@ -106,7 +95,7 @@ class Puppet::Pops::Binder::BindingsComposer
     factory = Puppet::Pops::Binder::BindingsFactory
     contributions = []
     configured_layers = @config.layering_config.collect do |  layer_config |
-      # get contributions with effective categories
+      # get contributions
       contribs = configure_layer(layer_config, scope, diagnostics)
       # collect the contributions separately for later checking of category precedence
       contributions.concat(contribs)
@@ -114,12 +103,6 @@ class Puppet::Pops::Binder::BindingsComposer
       factory.named_layer(layer_config['name'], *contribs.collect {|c| c.bindings }.flatten)
     end
 
-    # must check all contributions are based on compatible category precedence
-    # (Note that contributions no longer contains the bindings as a side effect of setting them in the collected
-    # layer. The effective categories and the name remains in the contributed model; this is enough for checking
-    # and error reporting).
-    check_contribution_precedence(contributions)
-
     # Add the two system layers; the final - highest ("can not be overridden" layer), and the lowest
     # Everything here can be overridden 'default' layer.
     #
@@ -130,57 +113,8 @@ class Puppet::Pops::Binder::BindingsComposer
     factory.layered_bindings(*configured_layers)
   end
 
-  # Evaluates configured categorization and returns the result.
-  # The result is not cached.
-  # @api public
-  #
-  def effective_categories(scope)
-    unevaluated_categories = @config.categorization
-    parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    file_source = @config.config_file or "defaults in: #{__FILE__}"
-    evaluated_categories = unevaluated_categories.collect do |category_tuple|
-      evaluated_categories = [ category_tuple[0], parser.evaluate_string( scope, parser.quote( category_tuple[1] ), file_source ) ]
-      if evaluated_categories[1].is_a?(String)
-        # category values are always in lower case
-        evaluated_categories[1] = evaluated_categories[1].downcase
-      else
-        raise ArgumentError, "Categorization value must be a string, category #{evaluated_categories[0]} evaluation resulted in a: '#{result[1].class}'"
-      end
-      evaluated_categories
-    end
-    Puppet::Pops::Binder::BindingsFactory::categories(evaluated_categories)
-  end
-
   private
 
-  # Checks that contribution's effective categorization is in the same relative order as in the overall
-  # categorization precedence.
-  #
-  def check_contribution_precedence(contributions)
-    cat_prec = { }
-    @config.categorization.each_with_index {|c, i| cat_prec[ c[0] ] = i }
-    contributions.each() do |contrib|
-      # Contributions that do not specify their opinion about categorization silently accepts the precedence
-      # set in the root configuration - and may thus produce an unexpected result
-      #
-      next unless ec = contrib.effective_categories
-      next unless categories = ec.categories
-      prev_prec = -1
-      categories.each do |c|
-        prec = cat_prec[c.categorization]
-        issues = Puppet::Pops::Binder::BinderIssues
-        unless prec
-          diagnostics.accept(issues::MISSING_CATEGORY_PRECEDENCE, c, :categorization => c.categorization)
-          next
-        end
-        unless prec > prev_prec
-          diagnostics.accept(issues::PRECEDENCE_MISMATCH_IN_CONTRIBUTION, c, :categorization => c.categorization)
-        end
-        prev_prec = prec
-      end
-    end
-  end
-
   def configure_layer(layer_description, scope, diagnostics)
     name = layer_description['name']
 

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

@@ -78,7 +78,6 @@
 # @example Create a NamedBinding with content
 #   result = Puppet::Pops::Binder::BindingsFactory.named_bindings("mymodule::mybindings") do
 #     bind.name("foo").to(42)
-#     when_in_category("node", "kermit.example.com").bind.name("foo").to(43)
 #     bind.string.name("site url").to("http://www.example.com")
 #   end
 #   result.model()
@@ -154,39 +153,6 @@ module Puppet::Pops::Binder::BindingsFactory
       builder.instance_eval(&block) if block_given?
       builder
     end
-
-    # Adds a categorized bindings to this container. Returns a BindingsContainerBuilder to allow adding
-    # bindings in the newly created container. An optional block may be given which is evaluated using `instance_eval`.
-    # @param categorization [String] the name of the categorization e.g. 'node'
-    # @param category_value [String] the value in that category e.g. 'kermit.example.com'
-    # @return [BindingsContainerBuilder] the builder for the created categorized bindings container
-    # @api public
-    #
-    def when_in_category(categorization, category_value, &block)
-      when_in_categories({categorization => category_value}, &block)
-    end
-
-    # Adds a categorized bindings to this container. Returns a BindingsContainerBuilder to allow adding
-    # bindings in the newly created container.
-    # The result is that a processed request must match all the given categorizations
-    # with the given values. An optional block may be given which is evaluated using `instance_eval`.
-    # @param categories_hash Hash[String, String] a hash with categorization and categorization value entries
-    # @return [BindingsContainerBuilder] the builder for the created categorized bindings container
-    # @api public
-    #
-    def when_in_categories(categories_hash, &block)
-      binding = Puppet::Pops::Binder::Bindings::CategorizedBindings.new()
-      categories_hash.each do |k,v|
-          pred = Puppet::Pops::Binder::Bindings::Category.new()
-          pred.categorization = k
-          pred.value = v
-          binding.addPredicates(pred)
-        end
-      model.addBindings(binding)
-      builder = BindingsContainerBuilder.new(binding)
-      builder.instance_eval(&block) if block_given?
-      builder
-    end
   end
 
   # Builds a Binding via convenience methods.
@@ -228,6 +194,13 @@ module Puppet::Pops::Binder::BindingsFactory
       self
     end
 
+    # Sets the binding to be final (it may not be overridden)
+    # @api public
+    def final
+      model.final = true
+      self
+    end
+
     # Makes the binding a multibind contribution to the given multibind id
     # @param id [String] the multibind id to contribute this binding to
     # @api public
@@ -283,17 +256,17 @@ module Puppet::Pops::Binder::BindingsFactory
     end
 
     # Sets the type of the binding to Pattern.
-    # @return [Puppet::Pops::Types::PPatternType] the type
+    # @return [Puppet::Pops::Types::PRegexpType] the type
     # @api public
     def pattern()
       type(T.pattern())
     end
 
-    # Sets the type of the binding to the abstract type Literal.
-    # @return [Puppet::Pops::Types::PLiteralType] the type
+    # Sets the type of the binding to the abstract type Scalar.
+    # @return [Puppet::Pops::Types::PScalarType] the type
     # @api public
-    def literal()
-      type(T.literal())
+    def scalar()
+      type(T.scalar())
     end
 
     # Sets the type of the binding to the abstract type Data.
@@ -383,6 +356,9 @@ module Puppet::Pops::Binder::BindingsFactory
       case producer
       when Class
         producer = Puppet::Pops::Binder::BindingsFactory.instance_producer(producer.name, *args)
+      when Puppet::Pops::Model::Program
+        # program is not an expression
+        producer = Puppet::Pops::Binder::BindingsFactory.evaluating_producer(producer.body)
       when Puppet::Pops::Model::Expression
         producer = Puppet::Pops::Binder::BindingsFactory.evaluating_producer(producer)
       when Puppet::Pops::Binder::Bindings::ProducerDescriptor
@@ -619,15 +595,12 @@ module Puppet::Pops::Binder::BindingsFactory
   # @param name [String] the name of the contributed bindings (for human use in messages/logs only)
   # @param named_bindings [Puppet::Pops::Binder::Bindings::NamedBindings, Array<Puppet::Pops::Binder::Bindings::NamedBindings>] the
   #   named bindings to include
-  # @param effective_categories [Puppet::Pops::Binder::Bindings::EffectiveCategories] the contributors opinion about categorization
-  #   this is used to ensure consistent use of categories.
   #
-  def self.contributed_bindings(name, named_bindings, effective_categories)
+  def self.contributed_bindings(name, named_bindings)
     cb = Puppet::Pops::Binder::Bindings::ContributedBindings.new()
     cb.name = name
     named_bindings = [named_bindings] unless named_bindings.is_a?(Array)
     named_bindings.each {|b| cb.addBindings(b) }
-    cb.effective_categories = effective_categories
     cb
   end
 
@@ -778,21 +751,6 @@ module Puppet::Pops::Binder::BindingsFactory
     p
   end
 
-  # Creates an EffectiveCategories from a list of tuples `[categorization category ...]`, or `[[categorization category] ...]`
-  # This method is used by backends to create a model of the effective categories.
-  # @api public
-  #
-  def self.categories(tuple_array)
-    result = Puppet::Pops::Binder::Bindings::EffectiveCategories.new()
-    tuple_array.flatten.each_slice(2) do |c|
-      cat = Puppet::Pops::Binder::Bindings::Category.new()
-      cat.categorization = c[0]
-      cat.value = c[1]
-      result.addCategories(cat)
-    end
-    result
-  end
-
   # Creates a NamedLayer. This is used by the bindings system to create a model of the layers.
   #
   # @api public

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

@@ -28,11 +28,8 @@ class Puppet::Pops::Binder::BindingsLabelProvider < Puppet::Pops::LabelProvider
   def label_HashMultibindProducerDescriptor o   ; "Hash Multibind Producer"                      end
   def label_Bindings o                          ; "Bindings"                                     end
   def label_NamedBindings o                     ; "Named Bindings"                               end
-  def label_Category o                          ; "Category '#{o.categorization}/#{o.value}'"    end
-  def label_CategorizedBindings o               ; "Categorized Bindings"                         end
   def label_LayeredBindings o                   ; "Layered Bindings"                             end
   def label_NamedLayer o                        ; "Layer '#{o.name}'"                            end
-  def label_EffectiveCategories o               ; "Effective Categories"                         end
   def label_ContributedBindings o               ; "Contributed Bindings"                         end
   def label_NamedArgument o                     ; "Named Argument"                               end
 

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

@@ -5,7 +5,8 @@ require 'rgen/metamodel_builder'
 # This means it can load a class from a gem, or from puppet modules.
 #
 class Puppet::Pops::Binder::BindingsLoader
-  @autoloader = Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings", :wrap => false)
+  @confdir = Puppet.settings[:confdir]
+#  @autoloader = Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings", :wrap => false)
 
   # Returns a XXXXX given a fully qualified class name.
   # Lookup of class is never relative to the calling namespace.
@@ -35,11 +36,19 @@ class Puppet::Pops::Binder::BindingsLoader
   def self.loadable?(basedir, name)
     # note, "lib" is added by the autoloader
     #
-    paths_for_name(name).find {|p| Puppet::FileSystem::File.exist?(File.join(basedir, "lib/puppet/bindings", p)+'.rb') }
+    paths_for_name(name).find {|p| Puppet::FileSystem.exist?(File.join(basedir, "lib/puppet/bindings", p)+'.rb') }
   end
 
   private
 
+  def self.loader()
+    unless Puppet.settings[:confdir] == @confdir
+      @confdir = Puppet.settings[:confdir] == @confdir
+      @autoloader = Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings", :wrap => false)
+    end
+    @autoloader
+  end
+
   def self.provide_from_string(scope, name)
     name_path = name.split('::')
     # always from the root, so remove an empty first segment
@@ -55,7 +64,7 @@ class Puppet::Pops::Binder::BindingsLoader
 
     unless result
       # Attempt to load it using the auto loader
-      paths_for_name(name).find {|path| @autoloader.load(path) }
+      paths_for_name(name).find {|path| loader.load(path) }
       result = Puppet::Bindings.resolve(scope, name)
     end
     result
@@ -76,4 +85,4 @@ class Puppet::Pops::Binder::BindingsLoader
     tr("-", "_").
     downcase
   end
-end
+end

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

@@ -47,11 +47,16 @@ module Puppet::Pops::Binder::Bindings
     has_attr 'value', Object
   end
 
-  # Produces a value by evaluating a Puppet DSL expression
+  # Produces a value by evaluating a Puppet DSL expression.
+  # Note that the expression is not contained as it is part of a Puppet::Pops::Model::Program.
+  # To include the expression in the serialization, the Program it is contained in must be
+  # contained in the same serialization. This can be achieved by containing it in the
+  # ContributedBindings that is the top of a BindingsModel produced and given to the Injector.
+  #
   # @api public
   #
   class EvaluatingProducerDescriptor < ProducerDescriptor
-    contains_one_uni 'expression', Puppet::Pops::Model::Expression
+    has_one 'expression', Puppet::Pops::Model::Expression
   end
 
   # An InstanceProducer creates an instance of the given class
@@ -133,6 +138,7 @@ module Puppet::Pops::Binder::Bindings
     has_attr 'name', String
     has_attr 'override', Boolean
     has_attr 'abstract', Boolean
+    has_attr 'final', Boolean
     # If set is a contribution in a multibind
     has_attr 'multibind_id', String, :lowerBound => 0
     # Invariant: Only multibinds may have lowerBound 0, all regular Binding must have a producer.
@@ -163,23 +169,6 @@ module Puppet::Pops::Binder::Bindings
     has_attr 'name', String
   end
 
-  # A category predicate (the request has to be in this category).
-  # @api public
-  #
-  class Category < Puppet::Pops::Model::PopsObject
-    has_attr 'categorization', String, :lowerBound => 1
-    has_attr 'value', String, :lowerBound => 1
-  end
-
-  # A container of Binding instances that are in effect when the
-  # predicates (min one) evaluates to true. Multiple predicates are handles as an 'and'.
-  # Note that 'or' semantics are handled by repeating the same rules.
-  # @api public
-  #
-  class CategorizedBindings < Bindings
-    contains_many_uni 'predicates', Category, :lowerBound => 1
-  end
-
   # A named layer of bindings having the same priority.
   # @api public
   class NamedLayer < Puppet::Pops::Model::PopsObject
@@ -194,22 +183,19 @@ module Puppet::Pops::Binder::Bindings
     contains_many_uni 'layers', NamedLayer
   end
 
-  # A list of categories consisting of categroization name and category value (i.e. the *state of the request*)
-  # @api public
-  #
-  class EffectiveCategories < Puppet::Pops::Model::PopsObject
-    # The order is from highest precedence to lowest
-    contains_many_uni 'categories', Category
-  end
-
   # ContributedBindings is a named container of one or more NamedBindings.
-  # The intent is that a bindings producer returns a ContributedBindings which in addition to the bindings
-  # may optionally contain provider's opinion about the precedence of categories, and their category values.
-  # This enables merging of bindings, and validation of consistency.
+  # The intent is that a bindings producer returns a ContributedBindings that identifies the contributor
+  # as opposed to the names of the different set of bindings. The ContributorBindings name is typically
+  # a technical name that indicates their source (a service).
+  #
+  # When EvaluatingProducerDescriptor is used, it holds a reference to an Expression. That expression
+  # should be contained in the programs referenced in the ContributedBindings that contains that producer.
+  # While the bindings model will still work if this is not the case, it will not serialize and deserialize
+  # correctly.
   #
   # @api public
   #
   class ContributedBindings < NamedLayer
-    contains_one_uni 'effective_categories', EffectiveCategories
+    contains_many_uni 'programs', Puppet::Pops::Model::Program
   end
 end

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

@@ -93,7 +93,7 @@ class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumpe
     result << expression_dumper.dump(o.expression)
   end
 
-  def dump_InstanceProducerDescriptor
+  def dump_InstanceProducerDescriptor o
     # TODO: o.arguments, o. transformer
     ['instance', o.class_name]
   end
@@ -171,20 +171,6 @@ class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumpe
     result
   end
 
-  def dump_Category o
-    ['category', o.categorization, do_dump(o.value)]
-  end
-
-  def dump_CategorizedBindings o
-    result = ['when', do_dump(o.predicates), :indent]
-    o.bindings.each do |b|
-      result << :break
-      result << do_dump(b)
-    end
-    result << :dedent
-    result
-  end
-
   def dump_LayeredBindings o
     result = ['layers', :indent]
       o.layers.each do |layer|
@@ -195,11 +181,7 @@ class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumpe
     result
   end
 
-  def dump_EffectiveCategories o
-    ['categories', do_dump(o.categories)]
-  end
-
   def dump_ContributedBindings o
-    ['contributed', o.name, do_dump(o.effective_categories), do_dump(o.bindings)]
+    ['contributed', o.name, do_dump(o.bindings)]
   end
 end