hiera 0.3.0 → 1.0.0rc4

data/lib/hiera/backend.rb

@@ -1,174 +1,187 @@
-class Hiera
-    module Backend
-        class << self
-            # 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
-            def datadir(backend, scope)
-                backend = backend.to_sym
-                default = "/var/lib/hiera"
-
-                if Config.include?(backend)
-                    parse_string(Config[backend][:datadir] || default, scope)
-                else
-                    parse_string(default, scope)
-                end
-            end
+require 'hiera/util'
 
-            # Finds the path to a datafile based on the Backend#datadir
-            # and extension
-            #
-            # If the file is not found nil is returned
-            def datafile(backend, scope, source, extension)
-                file = File.join([datadir(backend, scope), "#{source}.#{extension}"])
+class Hiera
+  module Backend
+    class << self
+      # 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
+      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
 
-                unless File.exist?(file)
-                    Hiera.debug("Cannot find datafile #{file}, skipping")
+      # Finds the path to a datafile based on the Backend#datadir
+      # and extension
+      #
+      # If the file is not found nil is returned
+      def datafile(backend, scope, source, extension)
+        file = File.join([datadir(backend, scope), "#{source}.#{extension}"])
 
-                    return nil
-                end
+        unless File.exist?(file)
+          Hiera.debug("Cannot find datafile #{file}, skipping")
 
-                return file
-            end
+          return nil
+        end
 
-            # Returns an appropriate empty answer dependant on resolution type
-            def empty_answer(resolution_type)
-                case resolution_type
-                when :array
-                    return []
-                when :hash
-                    return {}
-                else
-                    return nil
-                end
-            end
+        return file
+      end
+
+      # 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
+      def datasources(scope, override=nil, hierarchy=nil)
+        if hierarchy
+          hierarchy = [hierarchy]
+        elsif Config.include?(:hierarchy)
+          hierarchy = [Config[:hierarchy]].flatten
+        else
+          hierarchy = ["common"]
+        end
 
-            # 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
-            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
+        hierarchy.insert(0, override) if override
 
-            # Parse a string like '%{foo}' against a supplied
-            # scope and additional scope.  If either scope or
-            # extra_scope includes the varaible 'foo' it will
-            # be replaced else an empty string will be placed.
-            #
-            # If both scope and extra_data has "foo" scope
-            # will win.  See hiera-puppet for an example of
-            # this to make hiera aware of additional non scope
-            # variables
-            def parse_string(data, scope, extra_data={})
-                return nil unless data
-
-                tdata = data.clone
-
-                if tdata.is_a?(String)
-                    while tdata =~ /%\{(.+?)\}/
-                        var = $1
-                        val = scope[var] || extra_data[var] || ""
-
-                        # Puppet can return this for unknown scope vars
-                        val = "" if val == :undefined
-
-                        tdata.gsub!(/%\{#{var}\}/, val)
-                    end
-                end
-
-                return tdata
-            end
+        hierarchy.flatten.map do |source|
+          source = parse_string(source, scope)
+          yield(source) unless source == "" or source =~ /(^\/|\/\/|\/$)/
+        end
+      end
+
+      # Parse a string like '%{foo}' against a supplied
+      # scope and additional scope.  If either scope or
+      # extra_scope includes the varaible 'foo' it will
+      # be replaced else an empty string will be placed.
+      #
+      # If both scope and extra_data has "foo" scope
+      # will win.  See hiera-puppet for an example of
+      # this to make hiera aware of additional non scope
+      # variables
+      def parse_string(data, scope, extra_data={})
+        return nil unless data
+
+        tdata = data.clone
+
+        if tdata.is_a?(String)
+          while tdata =~ /%\{(.+?)\}/
+            begin
+              var = $1
+
+              val = ""
+
+              # Puppet can return :undefined for unknown scope vars,
+              # If it does then we still need to evaluate extra_data
+              # before returning an empty string.
+              if scope[var] && scope[var] != :undefined
+                  val = scope[var]
+              elsif extra_data[var]
+                  val = extra_data[var]
+              end
+            end until val != "" || var !~ /::(.+)/
+
+            tdata.gsub!(/%\{(::)?#{var}\}/, val)
+          end
+        end
 
-            # 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
-            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
+        return tdata
+      end
+
+      # 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
+      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
+
+      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
+
+      # 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
+      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 = new_answer.merge answer
+              else
+                answer = new_answer
+                break
+              end
             end
+          end
+        end
 
-            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
+        answer = resolve_answer(answer, resolution_type) unless answer.nil?
+        answer = parse_string(default, scope) if answer.nil? and default.is_a?(String)
 
-            # 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
-            def lookup(key, default, scope, order_override, resolution_type)
-                @backends ||= {}
-                answer = nil
-
-                Config[:backends].each do |backend|
-                    if constants.include?("#{backend.capitalize}_backend")
-                        @backends[backend] ||= Backend.const_get("#{backend.capitalize}_backend").new
-                        answer = @backends[backend].lookup(key, scope, order_override, resolution_type)
-
-                        break if answer
-                    end
-                end
-
-                answer = resolve_answer(answer, resolution_type)
-                answer = parse_string(default, scope) if answer.nil?
-
-                return default if answer == empty_answer(resolution_type)
-                return answer
-            end
-        end
+        return default if answer.nil?
+        return answer
+      end
     end
+  end
 end

data/lib/hiera/backend/yaml_backend.rb

@@ -1,49 +1,71 @@
 class Hiera
-    module Backend
-        class Yaml_backend
-            def initialize
-                require 'yaml'
-
-                Hiera.debug("Hiera YAML backend starting")
-            end
-
-            def lookup(key, scope, order_override, resolution_type)
-                answer = Backend.empty_answer(resolution_type)
-
-                Hiera.debug("Looking up #{key} in YAML backend")
-
-                Backend.datasources(scope, order_override) do |source|
-                    Hiera.debug("Looking for data source #{source}")
-
-                    yamlfile = Backend.datafile(:yaml, scope, source, "yaml") || next
-
-                    data = YAML.load_file(yamlfile)
-
-                    next if ! data
-                    next if data.empty?
-                    next unless data.include?(key)
-
-                    # 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)
-                    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 << new_answer
-                    when :hash
-                        raise Exception, "Hiera type mismatch: expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
-                        answer = new_answer.merge answer
-                    else
-                        answer = new_answer
-                        break
-                    end
-                end
-
-                return answer
-            end
+  module Backend
+    class Yaml_backend
+      def initialize
+        require 'yaml'
+        Hiera.debug("Hiera YAML backend starting")
+        @data  = Hash.new
+        @cache = Hash.new
+      end
+
+      def lookup(key, scope, order_override, resolution_type)
+        answer = nil
+
+        Hiera.debug("Looking up #{key} in YAML backend")
+
+        Backend.datasources(scope, order_override) do |source|
+          Hiera.debug("Looking for data source #{source}")
+          yamlfile = Backend.datafile(:yaml, scope, source, "yaml") || next
+
+          # If you call stale? BEFORE you do encounter the YAML.load_file line
+          # it will populate the @cache variable and return true. The second
+          # time you call it, it will return false because @cache has been
+          # populated. Because of this there are two conditions to check:
+          # is @data[yamlfile] populated AND is the cache stale.
+          if @data[yamlfile]
+            @data[yamlfile] = YAML.load_file(yamlfile) if stale?(yamlfile)
+          else
+            @data[yamlfile] = YAML.load_file(yamlfile)
+          end
+
+          next if ! @data[yamlfile]
+          next if @data[yamlfile].empty?
+          next unless @data[yamlfile].include?(key)
+          # 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[yamlfile][key], scope)
+          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 = new_answer.merge answer
+          else
+            answer = new_answer
+            break
+          end
         end
+
+        return answer
+      end
+
+      def stale?(yamlfile)
+        # NOTE: The mtime change in a file MUST be > 1 second before being
+        #       recognized as stale. File mtime changes within 1 second will
+        #       not be recognized.
+        stat    = File.stat(yamlfile)
+        current = { 'inode' => stat.ino, 'mtime' => stat.mtime, 'size' => stat.size }
+        return false if @cache[yamlfile] == current
+
+        @cache[yamlfile] = current
+        return true
+      end
     end
+  end
 end