bolt 0.19.1 → 0.20.0

data/vendored/hiera/lib/hiera/backend/json_backend.rb

@@ -1,58 +0,0 @@
-class Hiera
-  module Backend
-    class Json_backend
-      def initialize(cache=nil)
-        require 'json'
-
-        Hiera.debug("Hiera JSON backend starting")
-
-        @cache = cache || Filecache.new
-      end
-
-      def lookup(key, scope, order_override, resolution_type, context)
-        answer = nil
-        found = false
-
-        Hiera.debug("Looking up #{key} in JSON backend")
-
-        Backend.datasources(scope, order_override) do |source|
-          Hiera.debug("Looking for data source #{source}")
-
-          jsonfile = Backend.datafile(:json, scope, source, "json") || next
-
-          next unless File.exist?(jsonfile)
-
-          data = @cache.read_file(jsonfile, Hash) do |data|
-            JSON.parse(data)
-          end
-
-          next if data.empty?
-          next unless data.include?(key)
-          found = true
-
-          # for array resolution we just append to the array whatever
-          # we find, we then goes onto the next file and keep adding to
-          # the array
-          #
-          # for priority searches we break after the first found data item
-          new_answer = Backend.parse_answer(data[key], scope, {}, context)
-          case resolution_type.is_a?(Hash) ? :hash : resolution_type
-          when :array
-            raise Exception, "Hiera type mismatch for key '#{key}': expected Array and got #{new_answer.class}" unless new_answer.kind_of? Array or new_answer.kind_of? String
-            answer ||= []
-            answer << new_answer
-          when :hash
-            raise Exception, "Hiera type mismatch for key '#{key}': expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
-            answer ||= {}
-            answer = Backend.merge_answer(new_answer, answer, resolution_type)
-          else
-            answer = new_answer
-            break
-          end
-        end
-        throw :no_such_key unless found
-        return answer
-      end
-    end
-  end
-end

data/vendored/hiera/lib/hiera/backend/yaml_backend.rb

@@ -1,63 +0,0 @@
-class Hiera
-  module Backend
-    class Yaml_backend
-      def initialize(cache=nil)
-        require 'yaml'
-        Hiera.debug("Hiera YAML backend starting")
-
-        @cache = cache || Filecache.new
-      end
-
-      def lookup(key, scope, order_override, resolution_type, context)
-        answer = nil
-        found = false
-
-        Hiera.debug("Looking up #{key} in YAML backend")
-
-        Backend.datasourcefiles(:yaml, scope, "yaml", order_override) do |source, yamlfile|
-          data = @cache.read_file(yamlfile, Hash) do |data|
-            YAML.load(data) || {}
-          end
-
-          next if data.empty?
-          next unless data.include?(key)
-          found = true
-
-          # Extra logging that we found the key. This can be outputted
-          # multiple times if the resolution type is array or hash but that
-          # should be expected as the logging will then tell the user ALL the
-          # places where the key is found.
-          Hiera.debug("Found #{key} in #{source}")
-
-          # for array resolution we just append to the array whatever
-          # we find, we then goes onto the next file and keep adding to
-          # the array
-          #
-          # for priority searches we break after the first found data item
-          new_answer = Backend.parse_answer(data[key], scope, {}, context)
-          case resolution_type.is_a?(Hash) ? :hash : resolution_type
-          when :array
-            raise Exception, "Hiera type mismatch for key '#{key}': expected Array and got #{new_answer.class}" unless new_answer.kind_of? Array or new_answer.kind_of? String
-            answer ||= []
-            answer << new_answer
-          when :hash
-            raise Exception, "Hiera type mismatch for key '#{key}': expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
-            answer ||= {}
-            answer = Backend.merge_answer(new_answer, answer, resolution_type)
-          else
-            answer = new_answer
-            break
-          end
-        end
-        throw :no_such_key unless found
-        return answer
-      end
-
-      private
-
-      def file_exists?(path)
-        File.exist? path
-      end
-    end
-  end
-end

data/vendored/hiera/lib/hiera/config.rb

@@ -1,97 +0,0 @@
-class Hiera::Config
-  class << self
-    ##
-    # load takes a string or hash as input, strings are treated as filenames
-    # hashes are stored as data that would have been in the config file
-    #
-    # Unless specified it will only use YAML as backend with a
-    # hierarchy of 'nodes/%{::trusted.certname}' and 'common', and with a
-    # console logger.
-    #
-    # @return [Hash] representing the configuration.
-    def load(source)
-      @config = {:backends => ["yaml"],
-                 :hierarchy => ["nodes/%{::trusted.certname}", "common"],
-                 :merge_behavior => :native }
-
-      if source.is_a?(String)
-        if File.exist?(source)
-          config = begin
-                     yaml_load_file(source)
-                   rescue TypeError => detail
-                     case detail.message
-                     when /no implicit conversion from nil to integer/
-                       false
-                     else
-                       raise detail
-                     end
-                   end
-          if config
-            version = config['version'] || config[:version] || 3
-            if version >= 4
-              raise "v#{version} hiera.yaml is only to be used inside an environment or a module and cannot be given to the global hiera"
-            end
-            @config.merge! config
-          end
-        else
-          raise "Config file #{source} not found"
-        end
-      elsif source.is_a?(Hash)
-        @config.merge! source
-      end
-
-      @config[:backends] = [ @config[:backends] ].flatten
-
-      if @config.include?(:logger)
-        Hiera.logger = @config[:logger].to_s
-      else
-        @config[:logger] = "console"
-        Hiera.logger = "console"
-      end
-
-      self.validate!
-
-      @config
-    end
-
-    def validate!
-      case @config[:merge_behavior]
-      when :deep,'deep',:deeper,'deeper'
-        begin
-          require "deep_merge"
-          require "deep_merge/rails_compat"
-        rescue LoadError
-          raise Hiera::Error, "Must have 'deep_merge' gem installed for the configured merge_behavior."
-        end
-      end
-    end
-
-    ##
-    # yaml_load_file directly delegates to YAML.load_file and is intended to be
-    # a private, internal method suitable for stubbing and mocking.
-    #
-    # @return [Object] return value of {YAML.load_file}
-    def yaml_load_file(source)
-      YAML.load_file(source)
-    end
-    private :yaml_load_file
-
-    def load_backends
-      @config[:backends].each do |backend|
-        begin
-          require "hiera/backend/#{backend.downcase}_backend"
-        rescue LoadError => e
-          raise "Cannot load backend #{backend}: #{e}"
-        end
-      end
-    end
-
-    def include?(key)
-      @config.include?(key)
-    end
-
-    def [](key)
-      @config[key]
-    end
-  end
-end

data/vendored/hiera/lib/hiera/console_logger.rb

@@ -1,13 +0,0 @@
-class Hiera
-  module Console_logger
-    class << self
-      def warn(msg)
-        STDERR.puts("WARN: %s: %s" % [Time.now.to_s, msg])
-      end
-
-      def debug(msg)
-        STDERR.puts("DEBUG: %s: %s" % [Time.now.to_s, msg])
-      end
-    end
-  end
-end

data/vendored/hiera/lib/hiera/error.rb

@@ -1,4 +0,0 @@
-class Hiera
-  class Error < StandardError; end
-  class InvalidConfigurationError < Error; end
-end

data/vendored/hiera/lib/hiera/fallback_logger.rb

@@ -1,41 +0,0 @@
-# Select from a given list of loggers the first one that
-# it suitable and use that as the actual logger
-#
-# @api private
-class Hiera::FallbackLogger
-  # Chooses the first suitable logger. For all of the loggers that are
-  # unsuitable it will issue a warning using the suitable logger stating that
-  # the unsuitable logger is not being used.
-  #
-  # @param implementations [Array<Hiera::Logger>] the implementations to choose from
-  # @raises when there are no suitable loggers
-  def initialize(*implementations)
-    warnings = []
-    @implementation = implementations.find do |impl|
-      if impl.respond_to?(:suitable?)
-        if impl.suitable?
-          true
-        else
-          warnings << "Not using #{impl.name}. It does not report itself to be suitable."
-          false
-        end
-      else
-        true
-      end
-    end
-
-    if @implementation.nil?
-      raise "No suitable logging implementation found."
-    end
-
-    warnings.each { |message| warn(message) }
-  end
-
-  def warn(message)
-    @implementation.warn(message)
-  end
-
-  def debug(message)
-    @implementation.debug(message)
-  end
-end

data/vendored/hiera/lib/hiera/filecache.rb

@@ -1,86 +0,0 @@
-class Hiera
-  class Filecache
-    def initialize
-      @cache = {}
-    end
-
-    # Reads a file, optionally parse it in some way check the
-    # output type and set a default
-    #
-    # Simply invoking it this way will return the file contents
-    #
-    #    data = read("/some/file")
-    #
-    # But as most cases of file reading in hiera involves some kind
-    # of parsing through a serializer there's some help for those
-    # cases:
-    #
-    #    data = read("/some/file", Hash, {}) do |data|
-    #       JSON.parse(data)
-    #    end
-    #
-    # In this case it will read the file, parse it using JSON then
-    # check that the end result is a Hash, if it's not a hash or if
-    # reading/parsing fails it will return {} instead
-    #
-    # Prior to calling this method you should be sure the file exist
-    def read(path, expected_type = Object, default=nil, &block)
-      read_file(path, expected_type, &block)
-    rescue TypeError => detail
-      Hiera.debug("#{detail.message}, setting defaults")
-      @cache[path][:data] = default
-    rescue => detail
-      error = "Reading data from #{path} failed: #{detail.class}: #{detail}"
-      if default.nil?
-        raise detail
-      else
-        Hiera.debug(error)
-        @cache[path][:data] = default
-      end
-    end
-
-    # Read a file when it changes. If a file is re-read and has not changed since the last time
-    # then the last, processed, contents will be returned.
-    #
-    # The processed data can also be checked against an expected type. If the
-    # type does not match a TypeError is raised.
-    #
-    # No error handling is done inside this method. Any failed reads or errors
-    # in processing will be propagated to the caller
-    def read_file(path, expected_type = Object)
-      if stale?(path)
-        data = File.read(path, :encoding => 'BOM|UTF-8')
-        @cache[path][:data] = block_given? ? yield(data) : data
-
-        if !@cache[path][:data].is_a?(expected_type)
-          raise TypeError, "Data retrieved from #{path} is #{@cache[path][:data].class} not #{expected_type}"
-        end
-      end
-
-      @cache[path][:data]
-    end
-
-    private
-
-    def stale?(path)
-      meta = path_metadata(path)
-
-      @cache[path] ||= {:data => nil, :meta => nil}
-
-      if @cache[path][:meta] == meta
-        return false
-      else
-        @cache[path][:meta] = meta
-        return true
-      end
-    end
-
-    # This is based on the old caching in the YAML backend and has a
-    # resolution of 1 second, changes made within the same second of
-    # a previous read will be ignored
-    def path_metadata(path)
-      stat = File.stat(path)
-      {:inode => stat.ino, :mtime => stat.mtime, :size => stat.size}
-    end
-  end
-end

data/vendored/hiera/lib/hiera/interpolate.rb

@@ -1,121 +0,0 @@
-require 'hiera/backend'
-require 'hiera/recursive_guard'
-
-
-class Hiera::InterpolationInvalidValue < StandardError; end
-
-# @api private
-class Hiera::Interpolate
-  RX_INTERPOLATION = /%\{([^\}]*)\}/
-  RX_ONLY_INTERPOLATION = /^%\{([^\}]*)\}$/
-  RX_METHOD_AND_ARG = /^(\w+)\(([^)]*)\)$/
-
-  EMPTY_INTERPOLATIONS = {
-    '' => true,
-    '::' => true,
-    '""' => true,
-    "''" => true,
-    '"::"' => true,
-    "'::'" => true
-  }.freeze
-
-  INTERPOLATION_METHODS = {
-    'hiera' => :hiera_interpolate,
-    'scope' => :scope_interpolate,
-    'literal' => :literal_interpolate,
-    'alias' => :alias_interpolate
-  }.freeze
-
-  class << self
-    # These two patterns are never used but kept here anyway since they used to be public and therefore
-    # must be considered API. The class is now marked @api private and these should be removed in a
-    # future version
-    #
-    # @deprecated
-    INTERPOLATION = /%\{([^\}]*)\}/
-
-    # @deprecated
-    METHOD_INTERPOLATION = /%\{(scope|hiera|literal|alias)\(['"]([^"']*)["']\)\}/
-
-    def interpolate(data, scope, extra_data, context)
-      if data.is_a?(String)
-        # Wrapping do_interpolation in a gsub block ensures we process
-        # each interpolation site in isolation using separate recursion guards.
-        new_context = context.nil? ? {} : context.clone
-        new_context[:recurse_guard] ||= Hiera::RecursiveGuard.new
-        data.gsub(RX_INTERPOLATION) do |match|
-          (interp_val, interpolate_method) = do_interpolation(match, scope, extra_data, new_context)
-
-          if (interpolate_method == :alias_interpolate) && !interp_val.is_a?(String)
-            return interp_val if data.match(RX_ONLY_INTERPOLATION)
-            raise Hiera::InterpolationInvalidValue, "Cannot call alias in the string context"
-          else
-            interp_val
-          end
-        end
-      else
-        data
-      end
-    end
-
-    def do_interpolation(data, scope, extra_data, context)
-      if data.is_a?(String) && (match = data.match(RX_INTERPOLATION))
-        interpolation_variable = match[1]
-
-        # HI-494
-        return ['', nil] if EMPTY_INTERPOLATIONS[interpolation_variable.strip]
-
-        context[:recurse_guard].check(interpolation_variable) do
-          interpolate_method, key = get_interpolation_method_and_key(interpolation_variable, context)
-          interpolated_data = send(interpolate_method, data, key, scope, extra_data, context)
-
-          # Halt recursion if we encounter a literal.
-          return [interpolated_data, interpolate_method] if interpolate_method == :literal_interpolate
-
-          [do_interpolation(interpolated_data, scope, extra_data, context)[0], interpolate_method]
-        end
-      else
-        [data, nil]
-      end
-    end
-    private :do_interpolation
-
-    def get_interpolation_method_and_key(interpolation_variable, context)
-      if (match = interpolation_variable.match(RX_METHOD_AND_ARG))
-        Hiera.warn('Use of interpolation methods in hiera configuration file is deprecated') if context[:is_interpolate_config]
-        method = match[1]
-        method_sym = INTERPOLATION_METHODS[method]
-        raise Hiera::InterpolationInvalidValue, "Invalid interpolation method '#{method}'" unless method_sym
-        arg = match[2]
-        match_data = arg.match(Hiera::QUOTED_KEY)
-        raise Hiera::InterpolationInvalidValue, "Argument to interpolation method '#{method}' must be quoted, got '#{arg}'" unless match_data
-        [method_sym, match_data[1] || match_data[2]]
-      else
-        [:scope_interpolate, interpolation_variable]
-      end
-    end
-    private :get_interpolation_method_and_key
-
-    def scope_interpolate(data, key, scope, extra_data, context)
-      segments = Hiera::Util.split_key(key) { |problem| Hiera::InterpolationInvalidValue.new("#{problem} in interpolation expression: #{data}") }
-      catch(:no_such_key) { return Hiera::Backend.qualified_lookup(segments, scope, key) }
-      catch(:no_such_key) { Hiera::Backend.qualified_lookup(segments, extra_data, key) }
-    end
-    private :scope_interpolate
-
-    def hiera_interpolate(data, key, scope, extra_data, context)
-      Hiera::Backend.lookup(key, nil, scope, context[:order_override], :priority, context)
-    end
-    private :hiera_interpolate
-
-    def literal_interpolate(data, key, scope, extra_data, context)
-      key
-    end
-    private :literal_interpolate
-
-    def alias_interpolate(data, key, scope, extra_data, context)
-      Hiera::Backend.lookup(key, nil, scope, context[:order_override], :priority, context)
-    end
-    private :alias_interpolate
-  end
-end