hiera 2.0.0-x86-mingw32

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/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+$:.insert(0, File.join([File.dirname(__FILE__), "..", "lib"]))
+
+require 'rubygems'
+require 'rspec'
+require 'mocha'
+require 'hiera'
+require 'tmpdir'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  if Hiera::Util.microsoft_windows? && RUBY_VERSION =~ /^1\./
+    require 'win32console'
+    config.output_stream = $stdout
+    config.error_stream = $stderr
+    config.formatters.each { |f| f.instance_variable_set(:@output, $stdout) }
+  end
+
+  config.after :suite do
+    # Log the spec order to a file, but only if the LOG_SPEC_ORDER environment variable is
+    #  set.  This should be enabled on Jenkins runs, as it can be used with Nick L.'s bisect
+    #  script to help identify and debug order-dependent spec failures.
+    if ENV['LOG_SPEC_ORDER']
+      File.open("./spec_order.txt", "w") do |logfile|
+        config.instance_variable_get(:@files_to_run).each { |f| logfile.puts f }
+      end
+    end
+  end
+end
+
+# So everyone else doesn't have to include this base constant.
+module HieraSpec
+  FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), 'unit', 'fixtures') unless defined?(FIXTURE_DIR)
+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
+
+    if block_given?
+      begin
+        yield path
+      ensure
+        FileUtils.remove_entry_secure path
+      end
+    else
+      path
+    end
+  end
+end

data/spec/unit/backend/json_backend_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'hiera/backend/json_backend'
+
+class Hiera
+  module Backend
+    describe Json_backend do
+      before do
+        Hiera.stubs(:debug)
+        Hiera.stubs(:warn)
+        Hiera::Backend.stubs(:empty_answer).returns(nil)
+        @cache = mock
+        @backend = Json_backend.new(@cache)
+      end
+
+      describe "#initialize" do
+        it "should announce its creation" do # because other specs checks this
+          Hiera.expects(:debug).with("Hiera JSON backend starting")
+          Json_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(:json, {}, "one", "json").returns(nil)
+          Backend.expects(:datafile).with(:json, {}, "two", "json").returns(nil)
+
+          expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+        end
+
+        it "should retain the data types found in data files" do
+          Backend.expects(:datasources).yields("one").times(3)
+          Backend.expects(:datafile).with(:json, {}, "one", "json").returns("/nonexisting/one.json").times(3)
+          File.stubs(:exist?).with("/nonexisting/one.json").returns(true)
+
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"stringval" => "string", "boolval" => true, "numericval" => 1}).times(3)
+
+          @backend.lookup("stringval", {}, nil, :priority, nil).should == "string"
+          @backend.lookup("boolval", {}, nil, :priority, nil).should == true
+          @backend.lookup("numericval", {}, nil, :priority, nil).should == 1
+        end
+
+        it "should pick data earliest source that has it for priority searches" do
+          scope = {"rspec" => "test"}
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:json, scope, "one", "json").returns("/nonexisting/one.json")
+          Backend.expects(:datafile).with(:json, scope, "two", "json").never
+
+          File.stubs(:exist?).with("/nonexisting/one.json").returns(true)
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "test_%{rspec}"})
+
+          @backend.lookup("key", scope, nil, :priority, nil).should == "test_test"
+        end
+
+        it "should build an array of all data sources for array searches" do
+          Hiera::Backend.stubs(:empty_answer).returns([])
+          Backend.stubs(:parse_answer).with('answer', {}, {}, anything).returns("answer")
+          Backend.expects(:datafile).with(:json, {}, "one", "json").returns("/nonexisting/one.json")
+          Backend.expects(:datafile).with(:json, {}, "two", "json").returns("/nonexisting/two.json")
+
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+
+          File.expects(:exist?).with("/nonexisting/one.json").returns(true)
+          File.expects(:exist?).with("/nonexisting/two.json").returns(true)
+
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "answer"})
+          @cache.expects(:read_file).with("/nonexisting/two.json", Hash).returns({"key" => "answer"})
+
+          @backend.lookup("key", {}, nil, :array, nil).should == ["answer", "answer"]
+        end
+
+        it "should parse the answer for scope variables" do
+          Backend.stubs(:parse_answer).with('test_%{rspec}', {'rspec' => 'test'}, {}, anything).returns("test_test")
+          Backend.expects(:datasources).yields("one")
+          Backend.expects(:datafile).with(:json, {"rspec" => "test"}, "one", "json").returns("/nonexisting/one.json")
+
+          File.expects(:exist?).with("/nonexisting/one.json").returns(true)
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "test_%{rspec}"})
+
+          @backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil).should == "test_test"
+        end
+      end
+    end
+  end
+end

data/spec/unit/backend/yaml_backend_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'hiera/backend/yaml_backend'
+
+class Hiera
+  module Backend
+    class FakeCache
+      attr_accessor :value
+      def read(path, expected_type, default, &block)
+        read_file(path, expected_type, &block)
+      rescue => e
+        default
+      end
+
+      def read_file(path, expected_type, &block)
+        output = block.call(@value)
+        if !output.is_a? expected_type
+          raise TypeError
+        end
+        output
+      end
+    end
+
+    describe Yaml_backend do
+      before do
+        Config.load({})
+        Hiera.stubs(:debug)
+        Hiera.stubs(:warn)
+        @cache = FakeCache.new
+        @backend = Yaml_backend.new(@cache)
+      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 pick data earliest source that has it for priority searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).yields(["one", "/nonexisting/one.yaml"])
+          @cache.value = "---\nkey: answer"
+
+          @backend.lookup("key", {}, nil, :priority, nil).should == "answer"
+        end
+
+        describe "handling unexpected YAML values" do
+          before do
+            Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).yields(["one", "/nonexisting/one.yaml"])
+          end
+
+          it "throws :no_such_key when key is missing in YAML" do
+            @cache.value = "---\n"
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+          end
+
+          it "returns nil when the YAML value is nil" do
+            @cache.value = "key: ~\n"
+            @backend.lookup("key", {}, nil, :priority, nil).should be_nil
+          end
+
+          it "throws :no_such_key when the YAML file is false" do
+            @cache.value = ""
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+          end
+
+          it "raises a TypeError when the YAML value is not a hash" do
+            @cache.value = "---\n[one, two, three]"
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to raise_error(TypeError)
+          end
+        end
+
+        it "should build an array of all data sources for array searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"answer"})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>"answer"})
+
+          @backend.lookup("key", {}, nil, :array, nil).should == ["answer", "answer"]
+        end
+
+        it "should ignore empty hash of data sources for hash searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+
+          @backend.lookup("key", {}, nil, :hash, nil).should == {"a" => "answer"}
+        end
+
+        it "should build a merged hash of data sources for hash searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"b"=>"answer", "a"=>"wrong"}})
+
+          @backend.lookup("key", {}, nil, :hash, nil).should == {"a" => "answer", "b" => "answer"}
+        end
+
+        it "should fail when trying to << a Hash" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>["a", "answer"]})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+
+          expect {@backend.lookup("key", {}, nil, :array, nil)}.to raise_error(Exception, "Hiera type mismatch for key 'key': expected Array and got Hash")
+        end
+
+        it "should fail when trying to merge an Array" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>["a", "wrong"]})
+
+          expect { @backend.lookup("key", {}, nil, :hash, nil) }.to raise_error(Exception, "Hiera type mismatch for key 'key': expected Hash and got Array")
+        end
+
+        it "should parse the answer for scope variables" do
+          Backend.expects(:datasourcefiles).with(:yaml, {"rspec" => "test"}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"test_%{rspec}"})
+
+          @backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil).should == "test_test"
+        end
+
+        it "should retain datatypes found in yaml files" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"]).times(3)
+
+
+          @cache.value = "---\nstringval: 'string'\nboolval: true\nnumericval: 1"
+
+          @backend.lookup("stringval", {}, nil, :priority, nil).should == "string"
+          @backend.lookup("boolval", {}, nil, :priority, nil).should == true
+          @backend.lookup("numericval", {}, nil, :priority, nil).should == 1
+        end
+      end
+    end
+  end
+end