hiera 2.0.0-x64-mingw32

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

data/lib/hiera/noop_logger.rb

@@ -0,0 +1,8 @@
+class Hiera
+  module Noop_logger
+    class << self
+      def warn(msg);end
+      def debug(msg);end
+    end
+  end
+end

data/lib/hiera/puppet_logger.rb

@@ -0,0 +1,17 @@
+class Hiera
+  module Puppet_logger
+    class << self
+      def suitable?
+        defined?(::Puppet) == "constant"
+      end
+
+      def warn(msg)
+        Puppet.notice("hiera(): #{msg}")
+      end
+
+      def debug(msg)
+        Puppet.debug("hiera(): #{msg}")
+      end
+    end
+  end
+end

data/lib/hiera/recursive_guard.rb

@@ -0,0 +1,20 @@
+# Allow for safe recursive lookup of values during variable interpolation.
+#
+# @api private
+class Hiera::InterpolationLoop < StandardError; end
+
+class Hiera::RecursiveGuard
+  def initialize
+    @seen = []
+  end
+
+  def check(value, &block)
+    if @seen.include?(value)
+      raise Hiera::InterpolationLoop, "Detected in [#{@seen.join(', ')}]"
+    end
+    @seen.push(value)
+    ret = yield
+    @seen.pop
+    ret
+  end
+end

data/lib/hiera/util.rb

@@ -0,0 +1,47 @@
+class Hiera
+  module Util
+    module_function
+
+    def posix?
+      require 'etc'
+      Etc.getpwuid(0) != nil
+    end
+
+    def microsoft_windows?
+      return false unless file_alt_separator
+
+      begin
+        require 'win32/dir'
+        true
+      rescue LoadError => err
+        warn "Cannot run on Microsoft Windows without the win32-dir gem: #{err}"
+        false
+      end
+    end
+
+    def config_dir
+      if microsoft_windows?
+         File.join(common_appdata, 'PuppetLabs', 'code')
+      else
+        '/etc/puppetlabs/code'
+      end
+    end
+
+    def var_dir
+      if microsoft_windows?
+        File.join(common_appdata, 'PuppetLabs', 'code', 'hieradata')
+      else
+        '/etc/puppetlabs/code/hieradata'
+      end
+    end
+
+    def file_alt_separator
+      File::ALT_SEPARATOR
+    end
+
+    def common_appdata
+      Dir::COMMON_APPDATA
+    end
+  end
+end
+

data/lib/hiera/version.rb

@@ -0,0 +1,89 @@
+# The version method and constant are isolated in hiera/version.rb so that a
+# simple `require 'hiera/version'` allows a rubygems gemspec or bundler
+# Gemfile to get the hiera version of the gem install.
+#
+# The version is programatically settable because we want to allow the
+# Raketasks and such to set the version based on the output of `git describe`
+
+
+class Hiera
+  VERSION = "2.0.0"
+
+  ##
+  # version is a public API method intended to always provide a fast and
+  # lightweight way to determine the version of hiera.
+  #
+  # The intent is that software external to hiera be able to determine the
+  # hiera version with no side-effects.  The expected use is:
+  #
+  #     require 'hiera/version'
+  #     version = Hiera.version
+  #
+  # This function has the following ordering precedence.  This precedence list
+  # is designed to facilitate automated packaging tasks by simply writing to
+  # the VERSION file in the same directory as this source file.
+  #
+  #  1. If a version has been explicitly assigned using the Hiera.version=
+  #     method, return that version.
+  #  2. If there is a VERSION file, read the contents, trim any
+  #     trailing whitespace, and return that version string.
+  #  3. Return the value of the Hiera::VERSION constant hard-coded into
+  #     the source code.
+  #
+  # If there is no VERSION file, the method must return the version string of
+  # the nearest parent version that is an officially released version.  That is
+  # to say, if a branch named 3.1.x contains 25 patches on top of the most
+  # recent official release of 3.1.1, then the version method must return the
+  # string "3.1.1" if no "VERSION" file is present.
+  #
+  # By design the version identifier is _not_ intended to vary during the life
+  # a process.  There is no guarantee provided that writing to the VERSION file
+  # while a Hiera process is running will cause the version string to be
+  # updated.  On the contrary, the contents of the VERSION are cached to reduce
+  # filesystem accesses.
+  #
+  # The VERSION file is intended to be used by package maintainers who may be
+  # applying patches or otherwise changing the software version in a manner
+  # that warrants a different software version identifier.  The VERSION file is
+  # intended to be managed and owned by the release process and packaging
+  # related tasks, and as such should not reside in version control.  The
+  # VERSION constant is intended to be version controlled in history.
+  #
+  # Ideally, this behavior will allow package maintainers to precisely specify
+  # the version of the software they're packaging as in the following example:
+  #
+  #     $ git describe --match "1.2.*" > lib/hiera/VERSION
+  #     $ ruby -r hiera/version -e 'puts Hiera.version'
+  #     1.2.1-9-g9fda440
+  #
+  # @api public
+  #
+  # @return [String] containing the hiera version, e.g. "1.2.1"
+  def self.version
+    version_file = File.join(File.dirname(__FILE__), 'VERSION')
+    return @hiera_version if @hiera_version
+    if version = read_version_file(version_file)
+      @hiera_version = version
+    end
+    @hiera_version ||= VERSION
+  end
+
+  def self.version=(version)
+    @hiera_version = version
+  end
+
+  ##
+  # read_version_file reads the content of the "VERSION" file that lives in the
+  # same directory as this source code file.
+  #
+  # @api private
+  #
+  # @return [String] for example: "1.6.14-6-gea42046" or nil if the VERSION
+  #   file does not exist.
+  def self.read_version_file(path)
+    if File.exists?(path)
+      File.read(path).chomp
+    end
+  end
+  private_class_method :read_version_file
+end

data/lib/hiera.rb

@@ -0,0 +1,115 @@
+require 'yaml'
+
+class Hiera
+  require "hiera/error"
+  require "hiera/version"
+  require "hiera/config"
+  require "hiera/util"
+  require "hiera/backend"
+  require "hiera/console_logger"
+  require "hiera/puppet_logger"
+  require "hiera/noop_logger"
+  require "hiera/fallback_logger"
+  require "hiera/filecache"
+
+  class << self
+    attr_reader :logger
+
+    # Loggers are pluggable, just provide a class called
+    # Hiera::Foo_logger and respond to :warn and :debug
+    #
+    # See hiera-puppet for an example that uses the Puppet
+    # loging system instead of our own
+    def logger=(logger)
+      require "hiera/#{logger}_logger"
+
+      @logger = Hiera::FallbackLogger.new(
+        Hiera.const_get("#{logger.capitalize}_logger"),
+        Hiera::Console_logger)
+    rescue Exception => e
+      @logger = Hiera::Console_logger
+      warn("Failed to load #{logger} logger: #{e.class}: #{e}")
+    end
+
+    def warn(msg); @logger.warn(msg); end
+    def debug(msg); @logger.debug(msg); end
+  end
+
+  attr_reader :options, :config
+
+  # If the config option is a string its assumed to be a filename,
+  # else a hash of what would have been in the YAML config file
+  def initialize(options={})
+    options[:config] ||= File.join(Util.config_dir, 'hiera.yaml')
+
+    @config = Config.load(options[:config])
+
+    Config.load_backends
+  end
+
+  # Calls the backends to do the actual lookup.
+  #
+  # The _scope_ can be anything that responds to `[]`, if you have input
+  # data like a Puppet Scope that does not you can wrap that data in a
+  # class that has a `[]` method that fetches the data from your source.
+  # See hiera-puppet for an example of this.
+  #
+  # The order-override will insert as first in the hierarchy a data source
+  # of your choice.
+  #
+  # Possible values for the _resolution_type_ parameter:
+  #
+  # - _:priority_ - This is the default. First found value is returned and no merge is performed
+  # - _:array_ - An array merge lookup assembles a value from every matching level of the hierarchy. It retrieves all
+  #     of the (string or array) values for a given key, then flattens them into a single array of unique values.
+  #     If _priority_ lookup can be thought of as a “default with overrides” pattern, _array_ merge lookup can be though
+  #     of as “default with additions.”
+  # - _:hash_ - A hash merge lookup assembles a value from every matching level of the hierarchy. It retrieves all of
+  #     the (hash) values for a given key, then merges the hashes into a single hash. Hash merge lookups will fail with
+  #     an error if any of the values found in the data sources are strings or arrays. It only works when every value
+  #     found is a hash. The actual merge behavior is determined by looking up the keys `:merge_behavior` and
+  #     `:deep_merge_options` in the Hiera config. `:merge_behavior` can be set to `:deep`, :deeper` or `:native`
+  #     (explained in detail below).
+  # - _{ deep merge options }_ - Configured values for `:merge_behavior` and `:deep_merge_options`will be completely
+  #     ignored. Instead the _resolution_type_ will be a `:hash` merge where the `:merge_behavior` will be the value
+  #     keyed by `:behavior` in the given hash and the `:deep_merge_options` will be the remaining top level entries of
+  #     that same hash.
+  #
+  # Valid behaviors for the _:hash_ resolution type:
+  #
+  # - _native_ - Performs a simple hash-merge by overwriting keys of lower lookup priority.
+  # - _deeper_ - In a deeper hash merge, Hiera recursively merges keys and values in each source hash. For each key,
+  #     if the value is:
+  #        - only present in one source hash, it goes into the final hash.
+  #        - a string/number/boolean and exists in two or more source hashes, the highest priority value goes into
+  #          the final hash.
+  #        - an array and exists in two or more source hashes, the values from each source are merged into a single
+  #          array and de-duplicated (but not automatically flattened, as in an array merge lookup).
+  #        - a hash and exists in two or more source hashes, the values from each source are recursively merged, as
+  #          though they were source hashes.
+  #        - mismatched between two or more source hashes, we haven’t validated the behavior. It should act as
+  #          described in the deep_merge gem documentation.
+  # - _deep_ - In a deep hash merge, Hiera behaves the same as for _deeper_, except that when a string/number/boolean
+  #     exists in two or more source hashes, the lowest priority value goes into the final hash. This is considered
+  #     largely useless and should be avoided. Use _deeper_ instead.
+  #
+  # The _merge_ can be given as a hash with the mandatory key `:strategy` to denote the actual strategy. This
+  # is useful for the `:deeper` and `:deep` strategy since they can use additional options to control the behavior.
+  # The options can be passed as top level keys in the `merge` parameter when it is a given as a hash. Recognized
+  # options are:
+  #
+  #  - 'knockout_prefix' Set to string value to signify prefix which deletes elements from existing element. Defaults is _undef_
+  #  - 'sort_merged_arrays' Set to _true_ to sort all arrays that are merged together. Default is _false_
+  #  - 'unpack_arrays' Set to string value used as a deliminator to join all array values and then split them again. Default is _undef_
+  #  - 'merge_hash_arrays' Set to _true_ to merge hashes within arrays. Default is _false_
+  #
+  # @param key [String] The key to lookup
+  # @param default [Object,nil] The value to return when there is no match for _key_
+  # @param scope [#[],nil] The scope to use for the lookup
+  # @param order_override [#[]] An override that will considered the first source of lookup
+  # @param resolution_type [String,Hash<Symbol,String>] Symbolic resolution type or deep merge configuration
+  # @return [Object] The found value or the given _default_ value
+  def lookup(key, default, scope, order_override=nil, resolution_type=:priority)
+    Backend.lookup(key, default, scope, order_override, resolution_type)
+  end
+end