puppet 3.2.4 → 3.3.0.rc2

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

@@ -0,0 +1,28 @@
+# Configures validation suitable for the bindings model
+# @api public
+#
+class Puppet::Pops::Binder::BindingsValidatorFactory < Puppet::Pops::Validation::Factory
+  Issues = Puppet::Pops::Binder::BinderIssues
+
+  # Produces the checker to use
+  def checker diagnostic_producer
+    Puppet::Pops::Binder::BindingsChecker.new(diagnostic_producer)
+  end
+
+  # Produces the label provider to use
+  def label_provider
+    Puppet::Pops::Binder::BindingsLabelProvider.new()
+  end
+
+  # Produces the severity producer to use
+  def severity_producer
+    p = super
+
+    # Configure each issue that should **not** be an error
+    #
+    p[Issues::MISSING_BINDINGS] = :warning
+    p[Issues::MISSING_LAYERS]   = :warning
+
+    p
+  end
+end

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

@@ -0,0 +1,139 @@
+module Puppet::Pops::Binder::Config
+  # Class holding the Binder Configuration
+  # The configuration is obtained from the file 'binder_config.yaml'
+  # that must reside in the root directory of the site
+  # @api public
+  #
+  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
+    #
+    # @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"]
+    ]
+
+    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}
+    end
+
+    def confdir()
+      Puppet.settings[:confdir]
+    end
+
+    # Creates a new Config. The configuration is loaded from the file 'binder_config.yaml' which
+    # is expected to be found in confdir.
+    #
+    # @param diagnostics [DiagnosticProducer] collector of diagnostics
+    # @api public
+    #
+    def initialize(diagnostics)
+      @config_file = Puppet.settings[:binder_config]
+      # if file is stated, it must exist
+      # otherwise it is optional $confdir/binder_conf.yaml
+      # and if that fails, the default
+      case @config_file
+      when NilClass
+        # use the config file if it exists
+        rootdir = confdir
+        if rootdir.is_a?(String)
+          expanded_config_file = File.expand_path(File.join(rootdir, '/binder_config.yaml'))
+          if File.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 File.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) && File.exist?(@config_file)
+        @config_file = nil # use defaults
+      end
+
+      validator = BinderConfigChecker.new(diagnostics)
+      begin
+        data = @config_file ? YAML.load_file(@config_file) : default_config()
+        validator.validate(data, @config_file)
+      rescue Errno::ENOENT
+        diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, @config_file)
+      rescue Errno::ENOTDIR
+        diagnostics.accept(Issues::CONFIG_FILE_NOT_FOUND, @config_file)
+      rescue ::SyntaxError => e
+        diagnostics.accept(Issues::CONFIG_FILE_SYNTAX_ERROR, @config_file, :detail => e.message)
+      end
+
+      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
+
+    # The default_xxx methods exists to make it easier to do mocking in tests.
+
+    # @api private
+    def default_layers
+      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

@@ -0,0 +1,183 @@
+module Puppet::Pops::Binder::Config
+  # Validates the consistency of a Binder::BinderConfig
+  class BinderConfigChecker
+    # Create an instance with a diagnostic producer that will receive the result during validation
+    # @param diangostics [DiagnosticProducer] The producer that will receive the diagnostic
+    # @api public
+    #
+    def initialize(diagnostics)
+      @diagnostics = diagnostics
+      t = Puppet::Pops::Types
+      @type_calculator = t::TypeCalculator.new()
+      @array_of_string_type = t::TypeFactory.array_of(t::TypeFactory.string())
+    end
+
+    # Validate the consistency of the given data. Diagnostics will be emitted to the DiagnosticProducer
+    # that was set when this checker was created
+    #
+    # @param data [Object] The data read from the config file
+    # @param config_file [String] The full path of the file. Used in error messages
+    # @api public
+    #
+    def validate(data, config_file)
+      @unique_layer_names = Set.new()
+
+      if data.is_a?(Hash)
+        check_top_level(data, config_file)
+      else
+        accept(Issues::CONFIG_IS_NOT_HASH, config_file)
+      end
+    end
+
+    private
+
+    def accept(issue, semantic, options = {})
+      @diagnostics.accept(issue, semantic, options)
+    end
+
+    def check_top_level(data, config_file)
+      if layers = (data['layers'] || data[:layers])
+        check_layers(layers, config_file)
+      else
+        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
+        accept(Issues::CONFIG_VERSION_MISSING, config_file)
+      end
+      if extensions = data['extensions']
+        check_extensions(extensions, config_file)
+      end
+    end
+
+    def check_layers(layers, config_file)
+      unless layers.is_a?(Array)
+        accept(Issues::LAYERS_IS_NOT_ARRAY, config_file, :klass => data.class)
+      else
+        layers.each {|layer| check_layer(layer, config_file) }
+      end
+    end
+
+    def check_layer(layer, config_file)
+      unless layer.is_a?(Hash)
+        accept(Issues::LAYER_IS_NOT_HASH, config_file, :klass => layer.class)
+        return
+      end
+      layer.each_pair do |k, v|
+        case k
+        when 'name'
+          unless v.is_a?(String)
+            accept(Issues::LAYER_NAME_NOT_STRING, config_file, :class_name => v.class.name)
+          end
+
+          unless @unique_layer_names.add?(v)
+            accept(Issues::DUPLICATE_LAYER_NAME, config_file, :name => v.to_s )
+          end
+
+        when 'include'
+          check_bindings_references('include', v, config_file)
+
+        when 'exclude'
+          check_bindings_references('exclude', v, config_file)
+
+        when Symbol
+          accept(Issues::LAYER_ATTRIBUTE_IS_SYMBOL, config_file, :name => k.to_s)
+
+        else
+          accept(Issues::UNKNOWN_LAYER_ATTRIBUTE, config_file, :name => k.to_s )
+        end
+      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
+    # @param config_file [String] reference to the loaded config file
+    #
+    def check_bindings_references(kind, value, config_file)
+      return check_reference(value, kind, config_file) if value.is_a?(String)
+      accept(Issues::BINDINGS_REF_NOT_STRING_OR_ARRAY, config_file, :kind => kind ) unless value.is_a?(Array)
+      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 '/')
+    #
+    def check_reference(value, kind, config_file)
+      begin
+        uri = URI.parse(value)
+
+        unless uri.scheme
+          accept(Issues::MISSING_SCHEME, config_file, :uri => uri)
+        end
+        unless uri.path
+          accept(Issues::REF_WITHOUT_PATH, config_file, :uri => uri, :kind => kind)
+        end
+
+      rescue InvalidURIError => e
+        accept(Issues::BINDINGS_REF_INVALID_URI, config_file, :msg => e.message)
+      end
+    end
+
+    def check_extensions(extensions, config_file)
+      unless extensions.is_a?(Hash)
+        accept(Issues::EXTENSIONS_NOT_HASH, config_file, :actual => extensions.class.name)
+        return
+      end
+      # check known extensions
+      extensions.each_key do |key|
+        unless ['scheme_handlers', 'hiera_backends'].include? key
+          accept(Issues::UNKNOWN_EXTENSION, config_file, :extension => key)
+        end
+      end
+
+      if binding_schemes = extensions['scheme_handlers']
+        unless binding_schemes.is_a?(Hash)
+          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/diagnostic_producer.rb

@@ -0,0 +1,32 @@
+module Puppet::Pops::Binder::Config
+  # Generates validation diagnostics
+  class Puppet::Pops::Binder::Config::DiagnosticProducer
+    def initialize(acceptor)
+      @acceptor = acceptor
+      @severity_producer = Puppet::Pops::Validation::SeverityProducer.new
+    end
+
+    def accept(issue, semantic, arguments={})
+      arguments[:semantic] ||= semantic
+      severity = severity_producer.severity(issue)
+      @acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(severity, issue, nil, nil, arguments))
+    end
+
+    def errors?()
+      @acceptor.errors?
+    end
+
+    def severity_producer
+      p = @severity_producer
+      # All are errors, if there is need to mark some as warnings...
+      # p[Issues::XXX] = :warning
+
+      # ignored because there is a default
+      p[Puppet::Pops::Binder::Config::Issues::CONFIG_LAYERS_MISSING] = :ignore
+
+      # ignored because there is a default
+      p[Puppet::Pops::Binder::Config::Issues::CONFIG_CATEGORIES_MISSING] = :ignore
+      p
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+module Puppet::Pops::Binder::Config::Issues
+  # (see Puppet::Pops::Issues#issue)
+  def self.issue (issue_code, *args, &block)
+    Puppet::Pops::Issues.issue(issue_code, *args, &block)
+  end
+
+  CONFIG_FILE_NOT_FOUND = issue :CONFIG_FILE_NOT_FOUND do
+    "The binder configuration file: #{semantic} can not be found."
+  end
+
+  CONFIG_FILE_SYNTAX_ERROR = issue :CONFIG_FILE_SYNTAX_ERROR, :detail do
+    "Syntax error in configuration file: #{detail}"
+  end
+
+  CONFIG_IS_NOT_HASH = issue :CONFIG_IS_NOT_HASH do
+    "The configuration file '#{semantic}' has no hash at the top level"
+  end
+
+  CONFIG_LAYERS_MISSING = issue :CONFIG_LAYERS_MISSING do
+    "The configuration file '#{semantic}' has no 'layers' entry in the top level hash"
+  end
+
+  CONFIG_VERSION_MISSING = issue :CONFIG_VERSION_MISSING do
+    "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
+
+  DUPLICATE_LAYER_NAME = issue :DUPLICATE_LAYER_NAME, :name do
+    "Duplicate layer '#{name}' in configuration file #{semantic}"
+  end
+
+  UNKNOWN_LAYER_ATTRIBUTE = issue :UNKNOWN_LAYER_ATTRIBUTE, :name do
+    "Unknown layer attribute '#{name}' in configuration file #{semantic}"
+  end
+
+  BINDINGS_REF_NOT_STRING_OR_ARRAY = issue :BINDINGS_REF_NOT_STRING_OR_ARRAY, :kind do
+    "Configuration file #{semantic} has bindings reference in '#{kind}' that is neither a String nor an Array."
+  end
+
+  MISSING_SCHEME = issue :MISSING_SCHEME, :uri do
+    "Configuration file #{semantic} contains a bindings reference: '#{uri}' without scheme."
+  end
+
+  UNKNOWN_REF_SCHEME = issue :UNKNOWN_REF_SCHEME, :uri, :kind do
+    "Configuration file #{semantic} contains a bindings reference: '#{kind}' => '#{uri}' with unknown scheme"
+  end
+
+  REF_WITHOUT_PATH = issue :REF_WITHOUT_PATH, :uri, :kind do
+    "Configuration file #{semantic} contains a bindings reference: '#{kind}' => '#{uri}' without path"
+  end
+
+  BINDINGS_REF_INVALID_URI = issue :BINDINGS_REF_INVALID_URI, :msg do
+    "Configuration file #{semantic} contains a bindings reference: '#{kind}' => invalid uri, msg: '#{msg}'"
+  end
+
+  LAYER_ATTRIBUTE_IS_SYMBOL = issue :LAYER_ATTRIBUTE_IS_SYMBOL, :name do
+    "Configuration file #{semantic} contains a layer attribute '#{name}' that is a Symbol (should be String)"
+  end
+
+  LAYER_NAME_NOT_STRING = issue :LAYER_NAME_NOT_STRING, :class_name do
+    "Configuration file #{semantic} contains a layer name that is not a String, got a: '#{class_name}'"
+  end
+
+  CONFIG_WRONG_VERSION = issue :CONFIG_WRONG_VERSION, :expected, :actual do
+    "The configuration file '#{semantic}' has unsupported 'version', expected: #{expected}, but got: #{actual}."
+  end
+
+  EXTENSIONS_NOT_HASH = issue :EXTENSIONS_NOT_HASH, :actual do
+    "The configuration file '#{semantic}' contains 'extensions', expected: Hash, but got: #{actual}."
+  end
+
+  EXTENSION_BINDING_NOT_HASH = issue :EXTENSION_BINDING_NOT_HASH, :extension, :actual do
+    "The configuration file '#{semantic}' contains '#{extension}', expected: Hash, but got: #{actual}."
+  end
+
+  UNKNOWN_EXTENSION = issue :UNKNOWN_EXTENSION, :actual do
+    "The configuration file '#{semantic}' contains the unknown extension: #{extension}."
+  end
+end