hiera 2.0.0-x86-mingw32

data/lib/hiera/backend/json_backend.rb

@@ -0,0 +1,58 @@
+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/lib/hiera/backend/yaml_backend.rb

@@ -0,0 +1,63 @@
+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/lib/hiera/config.rb

@@ -0,0 +1,90 @@
+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 single
+    # 'common' hierarchy and console logger
+    #
+    # @return [Hash] representing the configuration.  e.g.
+    #   {:backends => "yaml", :hierarchy => "common"}
+    def load(source)
+      @config = {:backends => "yaml",
+                 :hierarchy => "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
+          @config.merge! config if config
+        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"
+        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
+          Hiera.warn "Cannot load backend #{backend}: #{e}"
+        end
+      end
+    end
+
+    def include?(key)
+      @config.include?(key)
+    end
+
+    def [](key)
+      @config[key]
+    end
+  end
+end

data/lib/hiera/console_logger.rb

@@ -0,0 +1,13 @@
+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/lib/hiera/error.rb

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

data/lib/hiera/fallback_logger.rb

@@ -0,0 +1,41 @@
+# 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/lib/hiera/filecache.rb

@@ -0,0 +1,86 @@
+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)
+        @cache[path][:data] = block_given? ? yield(data) : data
+
+        if !@cache[path][:data].is_a?(expected_type)
+          raise TypeError, "Data retrieved from #{path} is #{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/lib/hiera/interpolate.rb

@@ -0,0 +1,98 @@
+require 'hiera/backend'
+require 'hiera/recursive_guard'
+
+
+class Hiera::InterpolationInvalidValue < StandardError; end
+
+class Hiera::Interpolate
+  class << self
+    INTERPOLATION = /%\{([^\}]*)\}/
+    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.
+        context ||= {}
+        new_context = context.clone
+        new_context[:recurse_guard] ||= Hiera::RecursiveGuard.new
+        data.gsub(INTERPOLATION) do |match|
+          interp_val = do_interpolation(match, scope, extra_data, new_context)
+
+          # Get interp method in case we are aliasing
+          if data.is_a?(String) && (match = data.match(INTERPOLATION))
+            interpolate_method, key = get_interpolation_method_and_key(data)
+          else
+            interpolate_method = nil
+          end
+
+          if ( (interpolate_method == :alias_interpolate) and (!interp_val.is_a?(String)) )
+            if data.match("^#{INTERPOLATION}$")
+              return interp_val
+            else
+              raise Hiera::InterpolationInvalidValue, "Cannot call alias in the string context"
+            end
+          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(INTERPOLATION))
+        interpolation_variable = match[1]
+        context[:recurse_guard].check(interpolation_variable) do
+          interpolate_method, key = get_interpolation_method_and_key(data)
+          interpolated_data = send(interpolate_method, data, key, scope, extra_data, context)
+
+          # Halt recursion if we encounter a literal.
+          return interpolated_data if interpolate_method == :literal_interpolate
+
+          do_interpolation(interpolated_data, scope, extra_data, context)
+        end
+      else
+        data
+      end
+    end
+    private :do_interpolation
+
+    def get_interpolation_method_and_key(data)
+      if (match = data.match(METHOD_INTERPOLATION))
+        case match[1]
+        when 'hiera' then [:hiera_interpolate, match[2]]
+        when 'scope' then [:scope_interpolate, match[2]]
+        when 'literal' then [:literal_interpolate, match[2]]
+        when 'alias' then [:alias_interpolate, match[2]]
+        end
+      elsif (match = data.match(INTERPOLATION))
+        [:scope_interpolate, match[1]]
+      end
+    end
+    private :get_interpolation_method_and_key
+
+    def scope_interpolate(data, key, scope, extra_data, context)
+      segments = key.split('.')
+      catch(:no_such_key) { return Hiera::Backend.qualified_lookup(segments, scope) }
+      catch(:no_such_key) { Hiera::Backend.qualified_lookup(segments, extra_data) }
+    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