Module: Hiera::Backend

### Home Classes Methods

### In Files

- lib/hiera/backend.rb
- lib/hiera/backend/yaml_backend.rb
- lib/hiera/backend/json_backend.rb

### Namespace

- CLASS Hiera::Backend::Json_backend
- CLASS Hiera::Backend::Yaml_backend

### Methods

- ::datadir
- ::datafile
- ::datasources
- ::lookup
- ::merge_answer
- ::parse_answer
- ::parse_string
- ::resolve_answer

### Class/Module Index

Quicksearch

- Hiera
- Hiera::Backend
- Hiera::Backend::Json_backend
- Hiera::Backend::Yaml_backend
- Hiera::Config
- Hiera::Console_logger
- Hiera::FallbackLogger
- Hiera::Filecache
- Hiera::Noop_logger
- Hiera::Puppet_logger
- Hiera::RecursiveLookup
- Hiera::Util

No matching classes.

# Hiera::Backend

### Constants

INTERPOLATION

### Public Class Methods

datadir(backend, scope) click to toggle source

Data lives in /var/lib/hiera by default. If a backend supplies a datadir in the config it will be used and subject to variable expansion based on scope

    # File lib/hiera/backend.rb, line 17
    def datadir(backend, scope)
      backend = backend.to_sym
      default = Hiera::Util.var_dir

      if Config.include?(backend)
        parse_string(Config[backend][:datadir] || default, scope)
      else
        parse_string(default, scope)
      end
    end

datafile(backend, scope, source, extension) click to toggle source

Finds the path to a datafile based on the Backend#datadir and extension

If the file is not found nil is returned

    # File lib/hiera/backend.rb, line 32
    def datafile(backend, scope, source, extension)
      file = File.join([datadir(backend, scope), "#{source}.#{extension}"])

      unless File.exist?(file)
        Hiera.debug("Cannot find datafile #{file}, skipping")

        return nil
      end

      return file
    end

datasources(scope, override=nil, hierarchy=nil) click to toggle source

Constructs a list of data sources to search

If you give it a specific hierarchy it will just use that else it will use the global configured one, failing that it will just look in the 'common' data source.

An override can be supplied that will be pre-pended to the hierarchy.

The source names will be subject to variable expansion based on scope

    # File lib/hiera/backend.rb, line 55
    def datasources(scope, override=nil, hierarchy=nil)
      if hierarchy
        hierarchy = [hierarchy]
      elsif Config.include?(:hierarchy)
        hierarchy = [Config[:hierarchy]].flatten
      else
        hierarchy = ["common"]
      end

      hierarchy.insert(0, override) if override

      hierarchy.flatten.map do |source|
        source = parse_string(source, scope)
        yield(source) unless source == "" or source =~ /(^\/|\/\/|\/$)/
      end
    end

lookup(key, default, scope, order_override, resolution_type) click to toggle source

Calls out to all configured backends in the order they were specified. The first one to answer will win.

This lets you declare multiple backends, a possible use case might be in Puppet where a Puppet module declares default data using in-module data while users can override using JSON/YAML etc. By layering the backends and putting the Puppet one last you can override module author data easily.

Backend instances are cached so if you need to connect to any databases then do so in your constructor, future calls to your backend will not create new instances

    # File lib/hiera/backend.rb, line 175
    def lookup(key, default, scope, order_override, resolution_type)
      @backends ||= {}
      answer = nil

      Config[:backends].each do |backend|
        if constants.include?("#{backend.capitalize}_backend") || constants.include?("#{backend.capitalize}_backend".to_sym)
          @backends[backend] ||= Backend.const_get("#{backend.capitalize}_backend").new
          new_answer = @backends[backend].lookup(key, scope, order_override, resolution_type)

          if not new_answer.nil?
            case resolution_type
            when :array
              raise Exception, "Hiera type mismatch: 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: expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
              answer ||= {}
              answer = merge_answer(new_answer,answer)
            else
              answer = new_answer
              break
            end
          end
        end
      end

      answer = resolve_answer(answer, resolution_type) unless answer.nil?
      answer = parse_string(default, scope) if answer.nil? and default.is_a?(String)

      return default if answer.nil?
      return answer
    end

merge_answer(left,right) click to toggle source

Merges two hashes answers with the configured merge behavior.

    :merge_behavior: {:native|:deep|:deeper}

Deep merge options use the Hash utility function provided by [deep_merge](github.com/peritor/deep_merge)

    :native => Native Hash.merge
    :deep   => Use Hash.deep_merge
    :deeper => Use Hash.deep_merge!

    # File lib/hiera/backend.rb, line 151
    def merge_answer(left,right)
      case Config[:merge_behavior]
      when :deeper,'deeper'
        left.deep_merge!(right)
      when :deep,'deep'
        left.deep_merge(right)
      else # Native and undefined
        left.merge(right)
      end
    end

parse_answer(data, scope, extra_data={}) click to toggle source

Parses a answer received from data files

Ultimately it just pass the data through parse_string but it makes some effort to handle arrays of strings as well

    # File lib/hiera/backend.rb, line 109
    def parse_answer(data, scope, extra_data={})
      if data.is_a?(Numeric) or data.is_a?(TrueClass) or data.is_a?(FalseClass)
        return data
      elsif data.is_a?(String)
        return parse_string(data, scope, extra_data)
      elsif data.is_a?(Hash)
        answer = {}
        data.each_pair do |key, val|
          answer[key] = parse_answer(val, scope, extra_data)
        end

        return answer
      elsif data.is_a?(Array)
        answer = []
        data.each do |item|
          answer << parse_answer(item, scope, extra_data)
        end

        return answer
      end
    end

parse_string(data, scope, extra_data={}) click to toggle source

Parse a string like `'%{foo}'` against a supplied scope and additional scope. If either scope or extra_scope includes the variable 'foo', then it will be replaced else an empty string will be placed.

If both scope and extra_data has "foo", then the value in scope will be used.

@param data [String] The string to perform substitutions on.

    This will not be modified, instead a new string will be returned.

@param scope [#[]] The primary source of data for substitutions. @param extra_data [#[]] The secondary source of data for substitutions. @return [String] A copy of the data with all instances of `%{...}` replaced.

@api public

    # File lib/hiera/backend.rb, line 87
    def parse_string(data, scope, extra_data={})
      interpolate(data, Hiera::RecursiveLookup.new(scope, extra_data))
    end

resolve_answer(answer, resolution_type) click to toggle source

    # File lib/hiera/backend.rb, line 131
    def resolve_answer(answer, resolution_type)
      case resolution_type
      when :array
        [answer].flatten.uniq.compact
      when :hash
        answer # Hash structure should be preserved
      else
        answer
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.