puppet 4.10.0 → 5.0.0

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

@@ -1,201 +0,0 @@
-module Puppet::Pops
-module Binder
-# A validator/checker of a bindings model
-# @api public
-#
-class BindingsChecker
-  Bindings = Bindings
-  Issues = BinderIssues
-  Types = Types
-
-  attr_reader :type_calculator
-  attr_reader :acceptor
-
-  # @api public
-  def initialize(diagnostics_producer)
-    @@check_visitor     ||= Visitor.new(nil, "check", 0, 0)
-    @type_calculator      = Types::TypeCalculator.singleton
-    @expression_validator = Validation::ValidatorFactory_4_0.new().checker(diagnostics_producer)
-    @acceptor             = diagnostics_producer
-  end
-
-  # Validates the entire model by visiting each model element and calling `check`.
-  # The result is collected (or acted on immediately) by the configured diagnostic provider/acceptor
-  # given when creating this Checker.
-  #
-  # @api public
-  #
-  def validate(b)
-    check(b)
-    b.eAllContents.each {|c| check(c) }
-  end
-
-  # Performs binding validity check
-  # @api private
-  def check(b)
-    @@check_visitor.visit_this_0(self, b)
-  end
-
-  # Checks that a binding has a producer and a type
-  # @api private
-  def check_Binding(b)
-    # Must have a type
-    acceptor.accept(Issues::MISSING_TYPE, b) unless b.type.is_a?(Types::PAnyType)
-
-    # Must have a producer
-    acceptor.accept(Issues::MISSING_PRODUCER, b) unless b.producer.is_a?(Bindings::ProducerDescriptor)
-  end
-
-  # Checks that the producer is a Multibind producer and that the type is a PCollectionType
-  # @api private
-  def check_Multibinding(b)
-    # id is optional (empty id blocks contributions)
-
-    # A multibinding must have PCollectionType
-    acceptor.accept(Issues::MULTIBIND_TYPE_ERROR, b, {:actual_type => b.type})  unless b.type.is_a?(Types::PCollectionType)
-
-    # if the producer is nil, a suitable producer will be picked automatically
-    unless b.producer.nil? || b.producer.is_a?(Bindings::MultibindProducerDescriptor)
-      acceptor.accept(Issues::MULTIBIND_NOT_COLLECTION_PRODUCER, b, {:actual_producer => b.producer})
-    end
-  end
-
-  # Checks that the bindings object contains at least one binding. Then checks each binding in turn
-  # @api private
-  def check_Bindings(b)
-    acceptor.accept(Issues::MISSING_BINDINGS, b) unless has_entries?(b.bindings)
-  end
-
-  # Checks that a name has been associated with the bindings
-  # @api private
-  def check_NamedBindings(b)
-    acceptor.accept(Issues::MISSING_BINDINGS_NAME, b) unless has_chars?(b.name)
-    check_Bindings(b)
-  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)
-  end
-
-  # Checks that the binding has layers and that each layer has a name and at least one binding
-  # @api private
-  def check_LayeredBindings(b)
-    acceptor.accept(Issues::MISSING_LAYERS, b) unless has_entries?(b.layers)
-  end
-
-  # Checks that the non caching producer has a producer to delegate to
-  # @api private
-  def check_NonCachingProducerDescriptor(p)
-    acceptor.accept(Issues::PRODUCER_MISSING_PRODUCER, p) unless p.producer.is_a?(Bindings::ProducerDescriptor)
-  end
-
-  # Checks that a constant value has been declared in the producer and that the type
-  # of the value is compatible with the type declared in the binding
-  # @api private
-  def check_ConstantProducerDescriptor(p)
-    # the product must be of compatible type
-    # TODO: Likely to change when value becomes a typed Puppet Object
-    b = binding_parent(p)
-    if p.value.nil?
-      acceptor.accept(Issues::MISSING_VALUE, p, {:binding => b})
-    else
-      infered = type_calculator.infer(p.value)
-      unless type_calculator.assignable?(b.type, infered)
-        acceptor.accept(Issues::INCOMPATIBLE_TYPE, p, {:binding => b, :expected_type => b.type, :actual_type => infered})
-      end
-    end
-  end
-
-  # Checks that an expression has been declared in the producer
-  # @api private
-  def check_EvaluatingProducerDescriptor(p)
-    unless p.expression.is_a?(Model::Expression)
-      acceptor.accept(Issues::MISSING_EXPRESSION, p, {:binding => binding_parent(p)})
-    end
-  end
-
-  # Checks that a class name has been declared in the producer
-  # @api private
-  def check_InstanceProducerDescriptor(p)
-    acceptor.accept(Issues::MISSING_CLASS_NAME, p, {:binding => binding_parent(p)}) unless has_chars?(p.class_name)
-  end
-
-  # Checks that a type and a name has been declared. The type must be assignable to the type
-  # declared in the binding. The name can be an empty string to denote 'no name'
-  # @api private
-  def check_LookupProducerDescriptor(p)
-    b = binding_parent(p)
-    unless type_calculator.assignable(b.type, p.type)
-      acceptor.accept(Issues::INCOMPATIBLE_TYPE, p, {:binding => b, :expected_type => b.type, :actual_type => p.type })
-    end
-    acceptor.accept(Issues::MISSING_NAME, p, {:binding => b}) if p.name.nil? # empty string is OK
-  end
-
-  # Checks that a key has been declared, then calls producer_LookupProducerDescriptor to perform
-  # checks associated with the super class
-  # @api private
-  def check_HashLookupProducerDescriptor(p)
-    acceptor.accept(Issues::MISSING_KEY, p, {:binding => binding_parent(p)}) unless has_chars?(p.key)
-    check_LookupProducerDescriptor(p)
-  end
-
-  # Checks that the type declared in the binder is a PArrayType
-  # @api private
-  def check_ArrayMultibindProducerDescriptor(p)
-    b = binding_parent(p)
-    acceptor.accept(Issues::MULTIBIND_INCOMPATIBLE_TYPE, p, {:binding => b, :actual_type => b.type}) unless b.type.is_a?(Types::PArrayType)
-  end
-
-  # Checks that the type declared in the binder is a PHashType
-  # @api private
-  def check_HashMultibindProducerDescriptor(p)
-    b = binding_parent(p)
-    acceptor.accept(Issues::MULTIBIND_INCOMPATIBLE_TYPE, p, {:binding => b, :actual_type => b.type}) unless b.type.is_a?(Types::PHashType)
-  end
-
-  # Checks that the producer that this producer delegates to is declared
-  # @api private
-  def check_ProducerProducerDescriptor(p)
-    unless p.producer.is_a?(Bindings::ProducerDescriptor)
-      acceptor.accept(Issues::PRODUCER_MISSING_PRODUCER, p, {:binding => binding_parent(p)})
-    end
-  end
-
-  # @api private
-  def check_Expression(t)
-    @expression_validator.validate(t)
-  end
-
-  # @api private
-  def check_PAnyType(t)
-    # Do nothing
-  end
-
-  # Returns true if the argument is a non empty string
-  # @api private
-  def has_chars?(s)
-    s.is_a?(String) && !s.empty?
-  end
-
-  # @api private
-  def has_entries?(s)
-    !(s.nil? || s.empty?)
-  end
-
-  # @api private
-  def binding_parent(p)
-    begin
-      x = p.eContainer
-      if x.nil?
-        acceptor.accept(Issues::MODEL_OBJECT_IS_UNBOUND, p)
-        return nil
-      end
-      p = x
-    end while !p.is_a?(Bindings::AbstractBinding)
-    p
-  end
-end
-end
-end

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

@@ -1,181 +0,0 @@
-module Puppet::Pops
-module Binder
-# The BindingsComposer handles composition of multiple bindings sources
-# It is directed by a {Config::BinderConfig BinderConfig} that indicates how
-# the final composition should be layered, and what should be included/excluded in each layer
-#
-# The bindings composer is intended to be used once per environment as the compiler starts its work.
-#
-# TODO: Possibly support envdir: scheme / relative to environment root (== same as confdir if there is only one environment).
-#       This is probably easier to do after ENC changes described in ARM-8 have been implemented.
-# TODO: If same config is loaded in a higher layer, skip it in the lower (since it is meaningless to load it again with lower
-#       precedence. (Optimization, or possibly an error, should produce a warning).
-#
-require 'puppet/plugins/binding_schemes'
-
-class BindingsComposer
-
-  # The BindingsConfig instance holding the read and parsed, but not evaluated configuration
-  # @api public
-  #
-  attr_reader :config
-
-  # map of scheme name to handler
-  # @api private
-  attr_reader :scheme_handlers
-
-  # @return [Hash{String => Puppet::Module}] map of module name to module instance
-  # @api private
-  attr_reader :name_to_module
-
-  # @api private
-  attr_reader :confdir
-
-  # @api private
-  attr_reader :diagnostics
-
-  # Container of all warnings and errors produced while initializing and loading bindings
-  #
-  # @api public
-  attr_reader :acceptor
-
-  # @api public
-  def initialize()
-    @acceptor = Validation::Acceptor.new()
-    @diagnostics = Config::DiagnosticProducer.new(acceptor)
-    @config = Config::BinderConfig.new(@diagnostics)
-    if acceptor.errors?
-      IssueReporter.assert_and_report(acceptor, :message => 'Binding Composer: error while reading config.')
-      raise Puppet::DevError.new("Internal Error: IssueReporter did not raise exception for errors in bindings config.")
-    end
-  end
-
-  # Configures and creates the boot injector.
-  # The read config may optionally contain mapping of bindings scheme handler name to handler class, and
-  # mapping of biera2 backend symbolic name to backend class.
-  # If present, these are turned into bindings in the category 'extension' (which is only used in the boot injector) which
-  # has higher precedence than 'default'. This is done to allow users to override the default bindings for
-  # schemes and backends.
-  # @param scope [Puppet::Parser:Scope] the scope (used to find compiler and injector for the environment)
-  # @api private
-  #
-  def configure_and_create_injector(scope)
-    # create the injector (which will pick up the bindings registered above)
-    @scheme_handlers = SchemeHandlerHelper.new(scope)
-
-    # get extensions from the config
-    # ------------------------------
-    scheme_extensions = @config.scheme_extensions
-
-    # Define a named bindings that are known by the SystemBindings
-    boot_bindings = BindingsFactory.named_bindings(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'
-        bind do
-          name(scheme)
-          instance_of(Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_TYPE)
-          in_multibind(Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_KEY)
-          to_instance(class_name)
-          end
-      end
-    end
-
-    @injector = scope.compiler.create_boot_injector(boot_bindings.model)
-  end
-
-  # @return [Bindings::LayeredBindings]
-  def compose(scope)
-    # The boot injector is used to lookup scheme-handlers
-    configure_and_create_injector(scope)
-
-    # get all existing modules and their root path
-    @name_to_module = {}
-    scope.environment.modules.each {|mod| name_to_module[mod.name] = mod }
-
-    # setup the confdir
-    @confdir = Puppet.settings[:confdir]
-
-    factory = BindingsFactory
-    contributions = []
-    configured_layers = @config.layering_config.collect do |  layer_config |
-      # get contributions
-      contribs = configure_layer(layer_config, scope, diagnostics)
-      # collect the contributions separately for later checking of category precedence
-      contributions.concat(contribs)
-      # create a named layer with all the bindings for this layer
-      factory.named_layer(layer_config['name'], *contribs.collect {|c| c.bindings }.flatten)
-    end
-
-    # Add the two system layers; the final - highest ("can not be overridden" layer), and the lowest
-    # Everything here can be overridden 'default' layer.
-    #
-    configured_layers.insert(0, SystemBindings.final_contribution)
-    configured_layers.insert(-1, SystemBindings.default_contribution)
-
-    # and finally... create the resulting structure
-    factory.layered_bindings(*configured_layers)
-  end
-
-  private
-
-  def configure_layer(layer_description, scope, diagnostics)
-    name = layer_description['name']
-
-    # compute effective set of uris to load (and get rid of any duplicates in the process
-    included_uris = array_of_uris(layer_description['include'])
-    excluded_uris = array_of_uris(layer_description['exclude'])
-    effective_uris = Set.new(expand_included_uris(included_uris)).subtract(Set.new(expand_excluded_uris(excluded_uris)))
-
-    # Each URI should result in a ContributedBindings
-    effective_uris.collect { |uri| scheme_handlers[uri.scheme].contributed_bindings(uri, scope, self) }
-  end
-
-  def array_of_uris(descriptions)
-    return [] unless descriptions
-    descriptions = [descriptions] unless descriptions.is_a?(Array)
-    descriptions.collect {|d| URI.parse(d) }
-  end
-
-  def expand_included_uris(uris)
-    result = []
-    uris.each do |uri|
-      unless handler = scheme_handlers[uri.scheme]
-        raise ArgumentError, "Unknown bindings provider scheme: '#{uri.scheme}'"
-      end
-      result.concat(handler.expand_included(uri, self))
-    end
-    result
-  end
-
-  def expand_excluded_uris(uris)
-    result = []
-    uris.each do |uri|
-      unless handler = scheme_handlers[uri.scheme]
-        raise ArgumentError, "Unknown bindings provider scheme: '#{uri.scheme}'"
-      end
-      result.concat(handler.expand_excluded(uri, self))
-    end
-    result
-  end
-
-  class SchemeHandlerHelper
-    T = Types::TypeFactory
-    HASH_OF_HANDLER = T.hash_of(T.type_of(Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_TYPE))
-    def initialize(scope)
-      @scope = scope
-      @cache = nil
-    end
-    def [] (scheme)
-      load_schemes unless @cache
-      @cache[scheme]
-    end
-
-    def load_schemes
-      @cache = @scope.compiler.boot_injector.lookup(@scope, HASH_OF_HANDLER, Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_KEY) || {}
-    end
-  end
-
-end
-end
-end