puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/pops/binder/scheme_handler/confdir_hiera_scheme.rb

@@ -0,0 +1,67 @@
+# Similar to {Puppet::Pops::Binder::SchemeHandler::ModuleHieraScheme ModuleHieraScheme} but path is
+# relative to the `$confdir` instead of relative to a module root.
+#
+# Does not handle wild-cards.
+# @api public
+class Puppet::Pops::Binder::SchemeHandler::ConfdirHieraScheme < Puppetx::Puppet::BindingsSchemeHandler
+
+  # (Puppetx::Puppet::BindingsSchemeHandler.contributed_bindings)
+  #
+  def contributed_bindings(uri, scope, composer)
+    split_path = uri.path.split('/')
+    name = split_path[1]
+    confdir = composer.confdir
+    provider = Puppet::Pops::Binder::Hiera2::BindingsProvider.new(uri.to_s, File.join(confdir, uri.path), composer.acceptor)
+    provider.load_bindings(scope)
+  end
+
+  # This handler does not support wildcards.
+  # The given uri is simply returned in an array.
+  # @param uri [URI] the uri to expand
+  # @return [Array<URI>] the uri wrapped in an array
+  # @todo Handle optional and possibly hiera-1 hiera.yaml config file in the expected location (the same as missing)
+  # @api public
+  #
+  def expand_included(uri, composer)
+    result = []
+    if config_exist?(uri, composer)
+      result << uri unless is_ignored_hiera_version?(uri, composer)
+    else
+      result << uri unless is_optional?(uri)
+    end
+    result
+  end
+
+  # This handler does not support wildcards.
+  # The given uri is simply returned in an array.
+  # @param uri [URI] the uri to expand
+  # @return [Array<URI>] the uri wrapped in an array
+  # @api public
+  #
+  def expand_excluded(uri, composer)
+    [uri]
+  end
+
+  def config_exist?(uri, composer)
+    File.exist?(File.join(composer.confdir, uri.path, 'hiera.yaml'))
+  end
+
+  # A hiera.yaml that exists, is readable, can be loaded, and does not have version >= 2 set is ignored.
+  # All other conditions are reported as 'not ignored' even if there are errors; these will be handled later
+  # as if the hiera.yaml is a hiera-2 file.
+  # @api private
+  def is_ignored_hiera_version?(uri, composer)
+    config_file = File.join(composer.confdir, uri.path, 'hiera.yaml')
+    begin
+      data = YAML.load_file(config_file)
+      if data.is_a?(Hash)
+        ver = data[:version] || data['version']
+        return ver.nil? || ver < 2
+      end
+    rescue Errno::ENOENT
+    rescue Errno::ENOTDIR
+    rescue ::SyntaxError => e
+    end
+    return false
+  end
+end

data/lib/puppet/pops/binder/scheme_handler/confdir_scheme.rb

@@ -0,0 +1,34 @@
+require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
+
+# Similar to {Puppet::Pops::Binder::SchemeHandler::ModuleScheme ModuleScheme}, but relative to the config root.
+# Does not support wildcard expansion.
+#
+# URI
+# ---
+# The URI scheme is `confdir:/[<FQN>]['?' | [?optional]` where FQN is the fully qualified name of the bindings to load.
+# The referecence is made optional by using a URI query of `?` or `?optional`.
+#
+# @todo
+#   If the file to load is outside of the file system rooted at $confdir (in a gem, or just on the Ruby path), it can not
+#   be marked as optional as it will always be ignored.
+#
+class Puppet::Pops::Binder::SchemeHandler::ConfdirScheme < Puppet::Pops::Binder::SchemeHandler::SymbolicScheme
+
+  def expand_included(uri, composer)
+    fqn = fqn_from_path(uri)[1]
+    if is_optional?(uri)
+      if Puppet::Pops::Binder::BindingsLoader.loadable?(composer.confdir, fqn)
+        [URI.parse('confdir:/' + fqn)]
+      else
+        []
+      end
+    else
+      # assume it exists (do not give error if not, since it may be excluded later)
+      [URI.parse('confdir:/' + fqn)]
+    end
+  end
+
+  def expand_excluded(uri, composer)
+    [URI.parse("confdir:/#{fqn_from_path(uri)[1]}")]
+  end
+end

data/lib/puppet/pops/binder/scheme_handler/module_hiera_scheme.rb

@@ -0,0 +1,92 @@
+# The `module-hiera:` scheme uses the path to denote a directory relative to a module root
+# The path starts with the name of the module, or '*' to denote *any module*.
+#
+# @example All root hiera.yaml from all modules.
+#   module-hiera:/*
+#
+# @example The hiera.yaml from the module `foo`'s relative path `<foo root>/bar`.
+#   module-hiera:/foo/bar
+#
+class Puppet::Pops::Binder::SchemeHandler::ModuleHieraScheme < Puppetx::Puppet::BindingsSchemeHandler
+  # (Puppetx::Puppet::BindingsSchemeHandler.contributed_bindings)
+  # @api public
+  def contributed_bindings(uri, scope, composer)
+    split_path = uri.path.split('/')
+    name = split_path[1]
+    mod = composer.name_to_module[name]
+    provider = Puppet::Pops::Binder::Hiera2::BindingsProvider.new(uri.to_s, File.join(mod.path, split_path[ 2..-1 ]), composer.acceptor)
+    provider.load_bindings(scope)
+  end
+
+  # Expands URIs with wildcards and checks optionality.
+  # @param uri [URI] the uri to possibly expand
+  # @return [Array<URI>] the URIs to include
+  # @api public
+  #
+  def expand_included(uri, composer)
+    result = []
+    split_path = uri.path.split('/')
+    if split_path.size > 1 && split_path[-1].empty?
+      split_path.delete_at(-1)
+    end
+
+    # 0 = "", since a URI with a path must start with '/'
+    # 1 = '*' or the module name
+    case split_path[ 1 ]
+    when '*'
+      # create new URIs, one per module name that has a hiera.yaml file relative to its root
+      composer.name_to_module.each_pair do | name, mod |
+        if File.exist?(File.join(mod.path, split_path[ 2..-1 ], 'hiera.yaml' ))
+          path_parts =["", name] + split_path[2..-1]
+          result << URI.parse('module-hiera:'+File.join(path_parts))
+        end
+      end
+    when nil
+      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
+    else
+      # If uri has query that is empty, or the text 'optional' skip this uri if it does not exist
+      if query = uri.query()
+        if query == '' || query == 'optional'
+          if File.exist?(File.join(mod.path, split_path[ 2..-1 ], 'hiera.yaml' ))
+            result << URI.parse('module-hiera:' + uri.path)
+          end
+        end
+      else
+        # assume it exists (do not give error since it may be excluded later)
+        result << URI.parse('module-hiera:' + File.join(split_path))
+      end
+    end
+    result
+  end
+
+  # Expands URIs with wildcards and checks optionality.
+  # @param uri [URI] the uri to possibly expand
+  # @return [Array<URI>] the URIs to exclude
+  # @api public
+  #
+  def expand_excluded(uri, composer)
+    result = []
+    split_path = uri.path.split('/')
+    if split_path.size > 1 && split_path[-1].empty?
+      split_path.delete_at(-1)
+    end
+
+    # 0 = "", since a URI with a path must start with '/'
+    # 1 = '*' or the module name
+    case split_path[ 1 ]
+    when '*'
+      # create new URIs, one per module name that has a hiera.yaml file relative to its root
+      composer.name_to_module.each_pair do | name, mod |
+        path_parts =["", mod.name] + split_path[2..-1]
+        result << URI.parse('module-hiera:'+File.join(path_parts))
+      end
+
+    when nil
+      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
+    else
+      # create a clean copy (get rid of optional, fragments etc. and a trailing "/")
+      result << URI.parse('module-hiera:' + File.join(split_path))
+    end
+    result
+  end
+end

data/lib/puppet/pops/binder/scheme_handler/module_scheme.rb

@@ -0,0 +1,84 @@
+require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
+
+# The module scheme allows loading bindings using the Puppet autoloader.
+# Optional uris are handled by checking if the symbolic name can be resolved to a loadable file
+# from modules.
+# 
+# URI
+# ---
+# The uri is on the format: `module:/[fqn][? | ?optional]` where `fqn` is a fully qualified bindings name
+# starting with the module name or '*' to denote 'any module'. A URI query of `?` or `?optional` makes the
+# request optional; if no loadable file is found, it is simply skipped.
+#
+#
+# @todo
+#   Does currently only support checking of optionality against files under a module. If the result should be loaded
+#   from any other location it can not be marked as optional as it will be ignored.
+#
+class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::SchemeHandler::SymbolicScheme
+
+  # Expands URIs with wildcards and checks optionality.
+  # @param uri [URI] the uri to possibly expand
+  # @return [Array<URI>] the URIs to include
+  # @api public
+  #
+  def expand_included(uri, composer)
+    result = []
+    split_name, fqn = fqn_from_path(uri)
+
+    # supports wild card in the module name
+    case split_name[0]
+    when '*'
+      # create new URIs, one per module name that has a corresponding .rb file relative to its
+      # '<root>/lib/puppet/bindings/'
+      #
+      composer.name_to_module.each_pair do | mod_name, mod |
+        expanded_name_parts = [mod_name] + split_name[1..-1]
+        expanded_name = expanded_name_parts.join('::')
+        if Puppet::Pops::Binder::BindingsLoader.loadable?(mod.path, expanded_name)
+          result << URI.parse('module:/' + expanded_name)
+        end
+      end
+    when nil
+      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
+    else
+      joined_name = split_name.join('::')
+      # skip optional uri if it does not exist
+      if is_optional?(uri)
+        mod = composer.name_to_module[split_name[0]]
+        if mod && Puppet::Binder::BindingsLoader.loadable?(mod.path, joined_name)
+          result << URI.parse('module:/' + joined_name)
+        end
+      else
+        # assume it exists (do not give error if not, since it may be excluded later)
+        result << URI.parse('module:/' + joined_name)
+      end
+    end
+    result
+  end
+
+  # Expands URIs with wildcards
+  # @param uri [URI] the uri to possibly expand
+  # @return [Array<URI>] the URIs to exclude
+  # @api public
+  #
+  def expand_excluded(uri, composer)
+    result = []
+    split_name, fqn = fqn_from_path(uri)
+
+    case split_name[ 0 ]
+    when '*'
+      # create new URIs, one per module name
+      composer.name_to_module.each_pair do | name, mod |
+        result << URI.parse('module:/' + ([name] + split_name).join('::'))
+      end
+
+    when nil
+      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
+    else
+      # create a clean copy (get rid of optional, fragments etc. and any trailing stuff
+      result << URI.parse('module:/' + split_name.join('::'))
+    end
+    result
+  end
+end

data/lib/puppet/pops/binder/scheme_handler/symbolic_scheme.rb

@@ -0,0 +1,54 @@
+# Abstract base class for schemes based on symbolic names of bindings.
+# This class helps resolve symbolic names by computing a path from a fully qualified name (fqn).
+# There are also helper methods do determine if the symbolic name contains a wild-card ('*') in the first
+# portion of the fqn (with the convention that '*' means 'any module').
+#
+# @abstract
+# @api public
+#
+class Puppet::Pops::Binder::SchemeHandler::SymbolicScheme < Puppetx::Puppet::BindingsSchemeHandler
+
+  # Shared implementation for module: and confdir: since the distinction is only in checks if a symbolic name
+  # exists as a loadable file or not. Once this method is called it is assumed that the name is relative
+  # and that it should exist relative to some loadable ruby location.
+  #
+  # TODO: this needs to be changed once ARM-8 Puppet DSL concrete syntax is also supported.
+  # @api public
+  #
+  def contributed_bindings(uri, scope, composer)
+    fqn = fqn_from_path(uri)[1]
+    bindings = Puppet::Pops::Binder::BindingsLoader.provide(scope, fqn)
+    raise ArgumentError, "Cannot load bindings '#{uri}' - no bindings found." unless bindings
+    # Must clone as the the rest mutates the model
+    cloned_bindings = Marshal.load(Marshal.dump(bindings))
+    # Give no effective categories (i.e. ok with whatever categories there is)
+    Puppet::Pops::Binder::BindingsFactory.contributed_bindings(fqn, cloned_bindings, nil)
+  end
+
+  # @api private
+  def fqn_from_path(uri)
+    split_path = uri.path.split('/')
+    if split_path.size > 1 && split_path[-1].empty?
+      split_path.delete_at(-1)
+    end
+
+    fqn = split_path[ 1 ]
+    raise ArgumentError, "Module scheme binding reference has no name." unless fqn
+    split_name = fqn.split('::')
+    # drop leading '::'
+    split_name.shift if split_name[0] && split_name[0].empty?
+    [split_name, split_name.join('::')]
+  end
+
+  # True if super thinks it is optional or if it contains a wildcard.
+  # @return [Boolean] true if the uri represents an optional set of bindings.
+  # @api public
+  def is_optional?(uri)
+    super(uri) || has_wildcard?(uri)
+  end
+
+  # @api private
+  def has_wildcard?(uri)
+    (path = uri.path) && path.split('/')[1].start_with?('*::')
+  end
+end

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

@@ -0,0 +1,72 @@
+class Puppet::Pops::Binder::SystemBindings
+  # Constant with name used for bindings used during initialization of injector
+  ENVIRONMENT_BOOT_BINDINGS_NAME = 'puppet::env::injector::boot'
+
+  Factory = Puppet::Pops::Binder::BindingsFactory
+  @extension_bindings = Factory.named_bindings("puppet::extensions")
+  @default_bindings   = Factory.named_bindings("puppet::default")
+  # Bindings in effect when real injector is created
+  @injector_boot_bindings   = Factory.named_bindings("puppet::injector_boot")
+
+  def self.extensions()
+    @extension_bindings
+  end
+
+  def self.default_bindings()
+    @default_bindings
+  end
+
+  def self.injector_boot_bindings()
+    @injector_boot_bindings
+  end
+
+#  def self.env_boot_bindings()
+#    Puppet::Bindings[Puppet::Pops::Binder::SystemBindings::ENVIRONMENT_BOOT_BINDINGS_NAME]
+#  end
+
+  def self.final_contribution
+    effective_categories = Factory.categories([['common', 'true']])
+    Factory.contributed_bindings("puppet-final", [deep_clone(@extension_bindings.model)], effective_categories)
+  end
+
+  def self.default_contribution
+    effective_categories = Factory.categories([['common', 'true']])
+    Factory.contributed_bindings("puppet-default", [deep_clone(@default_bindings.model)], effective_categories)
+  end
+
+  def self.injector_boot_contribution(env_boot_bindings)
+    # Compose the injector_boot_bindings contributed from the puppet runtime book (i.e. defaults for
+    # extensions that should be active in the boot injector - see Puppetx initialization.
+    #
+    bindings = [deep_clone(@injector_boot_bindings.model), deep_clone(@injector_default_bindings)]
+
+    # Add the bindings that come from the bindings_composer as it may define custom extensions added in the bindings
+    # configuration. (i.e. bindings required to be able to lookup using bindings schemes and backends when
+    # configuring the real injector).
+    #
+    bindings << env_boot_bindings unless env_boot_bindings.nil?
+
+    # Use an 'extension' category for extension bindings to allow them to override the default
+    # bindings since they are placed in the same layer (this is done to avoid having a separate layer).
+    # The purpose for allowing overrides is that someone may want to replace say 'yaml' with a different version,
+    # (say one that uses a YAML implementation that actually works ok in ruby 1.8.7 ;-)), an encrypted parser, etc.
+    effective_categories = Factory.categories([['extension', 'true'],['common', 'true']])
+
+    # return the composition and the cateogires.
+    Factory.contributed_bindings("puppet-injector-boot", bindings, effective_categories)
+  end
+
+  def self.factory()
+    Puppet::Pops::Binder::BindingsFactory
+  end
+
+  def self.type_factory()
+    Puppet::Pops::Types::TypeFactory
+  end
+
+  private
+
+  def self.deep_clone(o)
+    Marshal.load(Marshal.dump(o))
+  end
+end

data/lib/puppet/pops/issue_reporter.rb

@@ -0,0 +1,75 @@
+class Puppet::Pops::IssueReporter
+
+  # @param acceptor [Puppet::Pops::Validation::Acceptor] the acceptor containing reported issues
+  # @option options [String] :message (nil) A message text to use as prefix in a single Error message
+  # @option options [Boolean] :emit_warnings (false) A message text to use as prefix in a single Error message
+  # @option options [Boolean] :emit_errors (true) whether errors should be emitted or only given message
+  # @option options [Exception] :exception_class (Puppet::ParseError) The exception to raise
+  #
+  def self.assert_and_report(acceptor, options)
+    return unless acceptor
+
+    max_errors = Puppet[:max_errors]
+    max_warnings = Puppet[:max_warnings] + 1
+    max_deprecations = Puppet[:max_deprecations] + 1
+    emit_warnings = options[:emit_warnings] || false
+    emit_errors = options[:emit_errors] || true
+    emit_message = options[:message]
+    emit_exception = options[:exception_class] || Puppet::ParseError
+
+    # If there are warnings output them
+    warnings = acceptor.warnings
+    if emit_warnings && warnings.size > 0
+      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      emitted_w = 0
+      emitted_dw = 0
+      acceptor.warnings.each do |w|
+        if w.severity == :deprecation
+          # Do *not* call Puppet.deprecation_warning it is for internal deprecation, not
+          # deprecation of constructs in manifests! (It is not designed for that purpose even if
+          # used throughout the code base).
+          #
+          Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
+          emitted_dw += 1
+        else
+          Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
+          emitted_w += 1
+        end
+        break if emitted_w > max_warnings && emitted_dw > max_deprecations # but only then
+      end
+    end
+
+    # If there were errors, report the first found. Use a puppet style formatter.
+    errors = acceptor.errors
+    if errors.size > 0
+      unless emit_errors
+        raise emit_exception.new(emit_message)
+      end
+      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      if errors.size == 1 || max_errors <= 1
+        # raise immediately
+        raise emit_exception.new(format_with_prefix(emit_message, formatter.format(errors[0])))
+      end
+      emitted = 0
+      if emit_message
+        Puppet.err(emit_message)
+      end
+      errors.each do |e|
+        Puppet.err(formatter.format(e))
+        emitted += 1
+        break if emitted >= max_errors
+      end
+      warnings_message = (emit_warnings && warnings.size > 0) ? ", and #{warnings.size} warnings" : ""
+      giving_up_message = "Found #{errors.size} errors#{warnings_message}. Giving up"
+      exception = emit_exception.new(giving_up_message)
+      exception.file = errors[0].file
+      raise exception
+    end
+    parse_result
+  end
+
+  def self.format_with_prefix(prefix, message)
+    return message unless prefix
+    [prefix, message].join(' ')
+  end
+end