hiera 0.3.0 → 1.0.0rc4

data/lib/hiera/config.rb

@@ -1,51 +1,53 @@
 class Hiera::Config
-    class << self
-        # 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
-        def load(source)
-            @config = {:backends => "yaml",
-                       :hierarchy => "common"}
-
-            if source.is_a?(String)
-                raise "Config file #{source} not found" unless File.exist?(source)
-
-                config = YAML.load_file(source)
-                @config.merge! config if config
-            elsif source.is_a?(Hash)
-                @config.merge! source
-            end
+  class << self
+    # 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
+    def load(source)
+      @config = {:backends => "yaml",
+                 :hierarchy => "common"}
+
+      if source.is_a?(String)
+        if File.exist?(source)
+          config = YAML.load_file(source)
+          @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
+      @config[:backends] = [ @config[:backends] ].flatten
 
-            if @config.include?(:logger)
-                Hiera.logger = @config[:logger].to_s
-            else
-                @config[:logger] = "console"
-                Hiera.logger = "console"
-            end
+      if @config.include?(:logger)
+        Hiera.logger = @config[:logger].to_s
+      else
+        @config[:logger] = "console"
+        Hiera.logger = "console"
+      end
 
-            @config
-        end
+      @config
+    end
 
-        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
+    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 include?(key)
+      @config.include?(key)
+    end
 
-        def [](key)
-            @config[key]
-        end
+    def [](key)
+      @config[key]
     end
+  end
 end

data/lib/hiera/console_logger.rb

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

@@ -1,8 +1,13 @@
 class Hiera
-    module Puppet_logger
-        class << self
-            def warn(msg); Puppet.notice("hiera(): #{msg}"); end
-            def debug(msg); Puppet.debug("hiera(): #{msg}"); end
-        end
+  module Puppet_logger
+    class << self
+      def warn(msg)
+        Puppet.notice("hiera(): #{msg}")
+      end
+
+      def debug(msg)
+        Puppet.debug("hiera(): #{msg}")
+      end
     end
+  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', 'hiera', 'etc')
+      else
+        '/etc'
+      end
+    end
+
+    def var_dir
+      if microsoft_windows?
+        File.join(common_appdata, 'PuppetLabs', 'hiera', 'var')
+      else
+        '/var/lib/hiera'
+      end
+    end
+
+    def file_alt_separator
+      File::ALT_SEPARATOR
+    end
+
+    def common_appdata
+      Dir::COMMON_APPDATA
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -7,13 +7,49 @@ require 'rspec/mocks'
 require 'mocha'
 
 RSpec.configure do |config|
-    config.mock_with :mocha
+  config.mock_with :mocha
 end
 
-class Puppet
-    class Parser
-        class Functions
-        end
+# In ruby 1.8.5 Dir does not have mktmpdir defined, so this monkey patches
+# Dir to include the 1.8.7 definition of that method if it isn't already defined.
+# Method definition borrowed from ruby-1.8.7-p357/lib/ruby/1.8/tmpdir.rb
+unless Dir.respond_to?(:mktmpdir)
+  def Dir.mktmpdir(prefix_suffix=nil, tmpdir=nil)
+    case prefix_suffix
+    when nil
+      prefix = "d"
+      suffix = ""
+    when String
+      prefix = prefix_suffix
+      suffix = ""
+    when Array
+      prefix = prefix_suffix[0]
+      suffix = prefix_suffix[1]
+    else
+      raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+    end
+    tmpdir ||= Dir.tmpdir
+    t = Time.now.strftime("%Y%m%d")
+    n = nil
+    begin
+      path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+      path << "-#{n}" if n
+      path << suffix
+      Dir.mkdir(path, 0700)
+    rescue Errno::EEXIST
+      n ||= 0
+      n += 1
+      retry
     end
-end
 
+    if block_given?
+      begin
+        yield path
+      ensure
+        FileUtils.remove_entry_secure path
+      end
+    else
+      path
+    end
+  end
+end

data/spec/unit/backend/yaml_backend_spec.rb

@@ -1,140 +1,189 @@
-require 'spec_helper'
-
+require 'tmpdir'
 require 'hiera/backend/yaml_backend'
+require 'hiera/backend'
+require 'fileutils'
+require 'spec_helper'
 
 class Hiera
-    module Backend
-        describe Yaml_backend do
-            before do
-                Hiera.stubs(:debug)
-                Hiera.stubs(:warn)
-                @backend = Yaml_backend.new
-            end
-
-            describe "#initialize" do
-                it "should announce its creation" do # because other specs checks this
-                    Hiera.expects(:debug).with("Hiera YAML backend starting")
-                    Yaml_backend.new
-                end
-            end
+  module Backend
+    describe Yaml_backend do
+      before do
+        Hiera.stubs(:debug)
+        Hiera.stubs(:warn)
+        @backend = Yaml_backend.new
+        @backend.stubs(:stale?).returns(true)
+      end
+
+      describe "#initialize" do
+        it "should announce its creation" do # because other specs checks this
+          Hiera.expects(:debug).with("Hiera YAML backend starting")
+          Yaml_backend.new
+        end
+      end
 
-            describe "#lookup" do
-                it "should look for data in all sources" do
-                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns(nil)
-                    Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns(nil)
+      describe "#lookup" do
+        it "should look for data in all sources" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns(nil)
+          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns(nil)
 
-                    @backend.lookup("key", {}, nil, :priority)
-                end
-
-                it "should pick data earliest source that has it for priority searches" do
-                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns(nil).never
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: answer"))
+          @backend.lookup("key", {}, nil, :priority)
+        end
 
-                    @backend.lookup("key", {}, nil, :priority).should == "answer"
-                end
+        it "should pick data earliest source that has it for priority searches" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns(nil).never
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: answer"))
 
-                it "should not look up missing data files" do
-                    Backend.expects(:datasources).multiple_yields(["one"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns(nil)
-                    YAML.expects(:load_file).never
+          @backend.lookup("key", {}, nil, :priority).should == "answer"
+        end
 
-                    @backend.lookup("key", {}, nil, :priority)
-                end
+        it "should not look up missing data files" do
+          Backend.expects(:datasources).multiple_yields(["one"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns(nil)
+          YAML.expects(:load_file).never
 
-                it "should return nil for empty data files" do
-                    Backend.expects(:datasources).multiple_yields(["one"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load(""))
+          @backend.lookup("key", {}, nil, :priority)
+        end
+
+        it "should return nil for empty data files" do
+          Backend.expects(:datasources).multiple_yields(["one"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load(""))
 
-                    @backend.lookup("key", {}, nil, :priority).should be_nil
-                end
+          @backend.lookup("key", {}, nil, :priority).should be_nil
+        end
 
-                it "should build an array of all data sources for array searches" do
-                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
+        it "should build an array of all data sources for array searches" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: answer"))
-                    YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey: answer"))
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: answer"))
+          YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey: answer"))
+
+          @backend.lookup("key", {}, nil, :array).should == ["answer", "answer"]
+        end
 
-                    @backend.lookup("key", {}, nil, :array).should == ["answer", "answer"]
-                end
+        it "should ignore empty hash of data sources for hash searches" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
 
-                it "should return empty hash of data sources for hash searches" do
-                    Backend.expects(:datasources).multiple_yields(["one"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load(""))
+          YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n a: answer"))
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load(""))
+          @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer"}
+        end
 
-                    @backend.lookup("key", {}, nil, :hash).should == {}
-                end
+        it "should build a merged hash of data sources for hash searches" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
 
-                it "should ignore empty hash of data sources for hash searches" do
-                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey:\n a: answer"))
+          YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n a: wrong\n b: answer"))
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load(""))
-                    YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n a: answer"))
+          @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer", "b" => "answer"}
+        end
 
-                    @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer"}
-                end
+        it "should fail when trying to << a Hash" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
 
-                it "should build a merged hash of data sources for hash searches" do
-                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey:\n- a\n- answer"))
+          YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n a: answer"))
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey:\n a: answer"))
-                    YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n a: wrong\n b: answer"))
+          lambda {@backend.lookup("key", {}, nil, :array)}.should raise_error(Exception, "Hiera type mismatch: expected Array and got Hash")
+        end
 
-                    @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer", "b" => "answer"}
-                end
+        it "should fail when trying to merge an Array" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
+          Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
 
-                it "should fail when trying to << a Hash" do
-                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey:\n a: answer"))
+          YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n- a\n- wrong"))
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey:\n- a\n- answer"))
-                    YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n a: answer"))
+          lambda {@backend.lookup("key", {}, nil, :hash)}.should raise_error(Exception, "Hiera type mismatch: expected Hash and got Array")
+        end
 
-                    lambda {@backend.lookup("key", {}, nil, :array)}.should raise_error(Exception, "Hiera type mismatch: expected Array and got Hash")
-                end
+        it "should parse the answer for scope variables" do
+          Backend.expects(:datasources).yields("one")
+          Backend.expects(:datafile).with(:yaml, {"rspec" => "test"}, "one", "yaml").returns("/nonexisting/one.yaml")
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: 'test_%{rspec}'"))
 
-                it "should fail when trying to merge an Array" do
-                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    Backend.expects(:datafile).with(:yaml, {}, "two", "yaml").returns("/nonexisting/two.yaml")
+          @backend.lookup("key", {"rspec" => "test"}, nil, :priority).should == "test_test"
+        end
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey:\n a: answer"))
-                    YAML.expects(:load_file).with("/nonexisting/two.yaml").returns(YAML.load("---\nkey:\n- a\n- wrong"))
+        it "should retain datatypes found in yaml files" do
+          Backend.expects(:datasources).yields("one").times(3)
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml").times(3)
 
-                    lambda {@backend.lookup("key", {}, nil, :hash)}.should raise_error(Exception, "Hiera type mismatch: expected Hash and got Array")
-                end
+          YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nstringval: 'string'\nboolval: true\nnumericval: 1")).times(3)
 
-                it "should parse the answer for scope variables" do
-                    Backend.expects(:datasources).yields("one")
-                    Backend.expects(:datafile).with(:yaml, {"rspec" => "test"}, "one", "yaml").returns("/nonexisting/one.yaml")
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: 'test_%{rspec}'"))
+          @backend.lookup("stringval", {}, nil, :priority).should == "string"
+          @backend.lookup("boolval", {}, nil, :priority).should == true
+          @backend.lookup("numericval", {}, nil, :priority).should == 1
+        end
+      end
+    end
 
-                    @backend.lookup("key", {"rspec" => "test"}, nil, :priority).should == "test_test"
-                end
+    describe '#stale?' do
+      before do
+        Hiera.stubs(:debug)
+        Hiera.stubs(:warn)
+        @backend = Yaml_backend.new
+        @fakestat = Struct.new(:ino, :mtime, :size)
+      end
+
+      def create_yaml_file(data, path)
+        File.open(path, 'w') do |f|
+          f.write(data)
+        end
+      end
 
-                it "should retain datatypes found in yaml files" do
-                    Backend.expects(:datasources).yields("one").times(3)
-                    Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns("/nonexisting/one.yaml").times(3)
+      def update_file(data, path)
+        File.open(path, 'a') do |f|
+          f.write(data)
+        end
+      end
+
+      it 'should report a stale cache if a data lookup has not been performed' do
+        tmp_yamlfile = Pathname(Dir.mktmpdir('yaml')) + 'yamlfile'
+        create_yaml_file({'foo' => 'bar'}.to_yaml, tmp_yamlfile)
+        @backend.stale?(tmp_yamlfile).should == true
+      end
+
+      describe 'lookup tests' do
+        before(:each) do
+          @tmp_yamlfile = Pathname(Dir.mktmpdir('yaml')) + 'yamlfile'
+          create_yaml_file({'foo' => 'bar'}.to_yaml, @tmp_yamlfile)
+          Backend.expects(:datasources).yields("one")
+          Backend.expects(:datafile).with(:yaml, {}, "one", "yaml").returns(@tmp_yamlfile)
+        end
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nstringval: 'string'\nboolval: true\nnumericval: 1")).times(3)
+        it 'should not report a stale cache after a data lookup' do
+          @backend.stale?(@tmp_yamlfile).should == true
+          @backend.lookup('foo', {}, nil, :priority).should == 'bar'
+          @backend.stale?(@tmp_yamlfile).should == false
+        end
 
-                    @backend.lookup("stringval", {}, nil, :priority).should == "string"
-                    @backend.lookup("boolval", {}, nil, :priority).should == true
-                    @backend.lookup("numericval", {}, nil, :priority).should == 1
-                end
-            end
+        [:ino, :mtime, :size].each do |attribute|
+          it "should report a stale cache if a backend file's #{attribute} has changed" do
+            @stat_instance = @fakestat.new(1234, 1234, 1234)
+            File.expects(:stat).with(@tmp_yamlfile).returns(@stat_instance).twice
+            @backend.stale?(@tmp_yamlfile).should == true
+            @backend.lookup('foo', {}, nil, :priority).should == 'bar'
+            @backend.stale?(@tmp_yamlfile).should == false
+            @stat_instance[attribute] += 1
+            File.unstub && File.expects(:stat).with(@tmp_yamlfile).returns(@stat_instance)
+            @backend.stale?(@tmp_yamlfile).should == true
+          end
         end
+      end
     end
+  end
 end