hiera 0.2.0 → 0.3.0

data/bin/hiera

@@ -61,12 +61,38 @@ def load_scope(source, type=:yaml)
 
         # Puppet makes dumb yaml files that do not promote data reuse.
         scope = scope.values if scope.is_a?(Puppet::Node::Facts)
+
     when :json
         raise "Cannot find scope #{type} file #{source}" unless File.exist?(source)
 
         require 'json'
 
         scope = JSON.load(File.read(source))
+
+    when :inventory_service
+        # For this to work the machine running the hiera command needs access to
+        # /facts REST endpoint on your inventory server.  This access is
+        # controlled in auth.conf and identification is by the certname of the
+        # machine running hiera commands.
+        #
+        # Another caveat is that if your inventory server isn't at the short dns
+        # name of 'puppet' you will need to set the inventory_sever option in
+        # your puppet.conf.  Set it in either the master or main sections.  It
+        # is fine to have the inventory_server option set even if the config
+        # doesn't have the fact_terminus set to rest.
+        begin
+          require 'puppet/util/run_mode'
+          $puppet_application_mode = Puppet::Util::RunMode[:master]
+          require 'puppet'
+          Puppet.settings.parse
+          Puppet::Node::Facts.indirection.terminus_class = :rest
+          scope = YAML.load(Puppet::Node::Facts.indirection.find(source).to_yaml)
+          # Puppet makes dumb yaml files that do not promote data reuse.
+          scope = scope.values if scope.is_a?(Puppet::Node::Facts)
+        rescue Exception => e
+            STDERR.puts "Puppet inventory service lookup failed: #{e.class}: #{e}"
+            exit 1
+        end
     else
         raise "Don't know how to load data type #{type}"
     end
@@ -90,6 +116,10 @@ OptionParser.new do |opts|
         options[:resolution_type] = :array
     end
 
+    opts.on("--hash", "-h", "Hash search") do
+        options[:resolution_type] = :hash
+    end
+
     opts.on("--config CONFIG", "-c", "Configuration file") do |v|
         if File.exist?(v)
             options[:config] = v
@@ -110,7 +140,7 @@ OptionParser.new do |opts|
 
     opts.on("--yaml SCOPE", "-y", "YAML format file to load scope from") do |v|
         begin
-            options[:scope] = load_scope(v, :json)
+            options[:scope] = load_scope(v)
         rescue Exception => e
             STDERR.puts "Could not load YAML scope: #{e.class}: #{e}"
             exit 1
@@ -125,6 +155,15 @@ OptionParser.new do |opts|
             exit 1
         end
     end
+
+    opts.on("--inventory_service IDENTITY", "-i", "Retrieve facts for a node via Puppet's inventory service as scope") do |v|
+        begin
+            options[:scope] = load_scope(v, :inventory_service)
+        rescue Exception => e
+            STDERR.puts "Could not load Puppet inventory service scope: #{e.class}: #{e}"
+            exit 1
+        end
+    end
 end.parse!
 
 # arguments can be:

data/lib/hiera.rb

@@ -2,11 +2,12 @@ require 'rubygems'
 require 'yaml'
 
 class Hiera
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
 
     autoload :Config, "hiera/config"
     autoload :Backend, "hiera/backend"
     autoload :Console_logger, "hiera/console_logger"
+    autoload :Puppet_logger, "hiera/puppet_logger"
 
     class << self
         def version
@@ -54,9 +55,6 @@ class Hiera
     #
     # The order-override will insert as first in the hierarchy a data source
     # of your choice.
-    #
-    # TODO: resolution_type is to eventually support top down priority based
-    #       lookups or bottom up merging type lookups like an ENC might need
     def lookup(key, default, scope, order_override=nil, resolution_type=:priority)
         Backend.lookup(key, default, scope, order_override, resolution_type)
     end

data/lib/hiera/backend.rb

@@ -36,6 +36,8 @@ class Hiera
                 case resolution_type
                 when :array
                     return []
+                when :hash
+                    return {}
                 else
                     return nil
                 end
@@ -65,7 +67,7 @@ class Hiera
 
                 hierarchy.flatten.map do |source|
                     source = parse_string(source, scope)
-                    yield(source) unless source == ""
+                    yield(source) unless source == "" or source =~ /(^\/|\/\/|\/$)/
                 end
             end
 
@@ -103,7 +105,9 @@ class Hiera
             # 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?(String)
+                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 = {}
@@ -125,7 +129,9 @@ class Hiera
             def resolve_answer(answer, resolution_type)
                 case resolution_type
                 when :array
-                    [answer].flatten.uniq.sort
+                    [answer].flatten.uniq.compact
+                when :hash
+                    answer # Hash structure should be preserved
                 else
                     answer
                 end
@@ -157,7 +163,11 @@ class Hiera
                     end
                 end
 
-                resolve_answer(answer, resolution_type) || parse_string(default, scope)
+                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
     end

data/lib/hiera/backend/yaml_backend.rb

@@ -19,6 +19,7 @@ class Hiera
 
                     data = YAML.load_file(yamlfile)
 
+                    next if ! data
                     next if data.empty?
                     next unless data.include?(key)
 
@@ -27,11 +28,16 @@ class Hiera
                     # 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
-                        answer << Backend.parse_answer(data[key], scope)
+                        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 = Backend.parse_answer(data[key], scope)
+                        answer = new_answer
                         break
                     end
                 end

data/lib/hiera/config.rb

@@ -12,7 +12,8 @@ class Hiera::Config
             if source.is_a?(String)
                 raise "Config file #{source} not found" unless File.exist?(source)
 
-                @config.merge! YAML.load_file(source)
+                config = YAML.load_file(source)
+                @config.merge! config if config
             elsif source.is_a?(Hash)
                 @config.merge! source
             end

data/spec/unit/backend/yaml_backend_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 require 'hiera/backend/yaml_backend'
 
@@ -31,31 +31,109 @@ class Hiera
                     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({"key" => "answer"})
+                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: answer"))
 
                     @backend.lookup("key", {}, nil, :priority).should == "answer"
                 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
+
+                    @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
+
                 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"))
+
+                    @backend.lookup("key", {}, nil, :array).should == ["answer", "answer"]
+                end
+
+                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(""))
+
+                    @backend.lookup("key", {}, nil, :hash).should == {}
+                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")
 
-                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns({"key" => "answer"})
-                    YAML.expects(:load_file).with("/nonexisting/two.yaml").returns({"key" => "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, :array).should == ["answer", "answer"]
+                    @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer"}
+                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")
+
+                    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"))
+
+                    @backend.lookup("key", {}, nil, :hash).should == {"a" => "answer", "b" => "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")
+
+                    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, :array)}.should raise_error(Exception, "Hiera type mismatch: expected Array and got Hash")
+                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")
+
+                    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"))
+
+                    lambda {@backend.lookup("key", {}, nil, :hash)}.should raise_error(Exception, "Hiera type mismatch: expected Hash and got Array")
                 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({"key" => "test_%{rspec}"})
-
+                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nkey: 'test_%{rspec}'"))
 
                     @backend.lookup("key", {"rspec" => "test"}, nil, :priority).should == "test_test"
                 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)
+
+                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns(YAML.load("---\nstringval: 'string'\nboolval: true\nnumericval: 1")).times(3)
+
+                    @backend.lookup("stringval", {}, nil, :priority).should == "string"
+                    @backend.lookup("boolval", {}, nil, :priority).should == true
+                    @backend.lookup("numericval", {}, nil, :priority).should == 1
+                end
             end
         end
     end

data/spec/unit/backend_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 class Hiera
     describe Backend do
@@ -21,6 +21,10 @@ class Hiera
                 Backend.empty_answer(:array).should == []
             end
 
+            it "should return {} for hash searches" do
+                Backend.empty_answer(:hash).should == {}
+            end
+
             it "should return nil otherwise" do
                 Backend.empty_answer(:meh).should == nil
             end
@@ -152,11 +156,31 @@ class Hiera
                 input = {"foo" => "test_%{rspec}_test", "bar" => ["test_%{rspec}_test", "test_%{rspec}_test"]}
                 Backend.parse_answer(input, {"rspec" => "test"}).should == {"foo"=>"test_test_test", "bar"=>["test_test_test", "test_test_test"]}
             end
+
+            it "should parse integers correctly" do
+              input = 1
+              Backend.parse_answer(input, {"rspec" => "test"}).should == 1
+            end
+
+            it "should parse floats correctly" do
+              input = 0.233
+              Backend.parse_answer(input, {"rspec" => "test"}).should == 0.233
+            end
+
+            it "should parse true boolean values correctly" do
+              input = true
+              Backend.parse_answer(input, {"rspec" => "test"}).should == true
+            end
+
+            it "should parse false boolean values correctly" do
+              input = false
+              Backend.parse_answer(input, {"rspec" => "test"}).should == false
+            end
         end
 
         describe "#resolve_answer" do
             it "should correctly parse array data" do
-                Backend.resolve_answer(["foo", ["foo", "foo"], "bar"], :array).should == ["bar", "foo"]
+                Backend.resolve_answer(["foo", ["foo", "foo"], "bar"], :array).should == ["foo", "bar"]
             end
 
             it "should just return the answer for non array data" do
@@ -189,6 +213,19 @@ class Hiera
                 Backend.lookup("key", "default", {}, nil, nil).should == "answer"
             end
 
+            it "should retain the datatypes as returned by the backend" do
+                Config.load({:yaml => {:datadir => "/tmp"}})
+                Config.load_backends
+
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("stringval", {}, nil, nil).returns("string")
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("boolval", {}, nil, nil).returns(false)
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("numericval", {}, nil, nil).returns(1)
+
+                Backend.lookup("stringval", "default", {}, nil, nil).should == "string"
+                Backend.lookup("boolval", "default", {}, nil, nil).should == false
+                Backend.lookup("numericval", "default", {}, nil, nil).should == 1
+            end
+
             it "should call to all backends till an answer is found" do
                 backend = mock
                 backend.expects(:lookup).returns("answer")
@@ -220,6 +257,27 @@ class Hiera
 
                 Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil).should == "test_test"
             end
+
+            it "should correctly handle string default data" do
+                Config.load({:yaml => {:datadir => "/tmp"}})
+                Config.load_backends
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, nil)
+                Backend.lookup("key", "test", {}, nil, nil).should == "test"
+            end
+
+            it "should correctly handle array default data" do
+                Config.load({:yaml => {:datadir => "/tmp"}})
+                Config.load_backends
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, :array)
+                Backend.lookup("key", ["test"], {}, nil, :array).should == ["test"]
+            end
+
+            it "should correctly handle hash default data" do
+                Config.load({:yaml => {:datadir => "/tmp"}})
+                Config.load_backends
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, :hash)
+                Backend.lookup("key", {"test" => "value"}, {}, nil, :hash).should == {"test" => "value"}
+            end
         end
     end
 end

data/spec/unit/config_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 class Hiera
     describe Config do
@@ -9,13 +9,27 @@ class Hiera
                 }.to raise_error("Config file /nonexisting not found")
             end
 
+            it "should raise error for missing config files" do
+                File.expects(:exist?).with("/nonexisting").returns(false)
+                YAML.expects(:load_file).with("/nonexisting").never
+
+                expect { Config.load("/nonexisting") }.should raise_error RuntimeError, /not found/
+            end
+
             it "should attempt to YAML load config files" do
                 File.expects(:exist?).with("/nonexisting").returns(true)
-                YAML.expects(:load_file).with("/nonexisting").returns({})
+                YAML.expects(:load_file).with("/nonexisting").returns(YAML.load("---\n"))
 
                 Config.load("/nonexisting")
             end
 
+            it "should use defaults on empty YAML config file" do
+                File.expects(:exist?).with("/nonexisting").returns(true)
+                YAML.expects(:load_file).with("/nonexisting").returns(YAML.load(""))
+
+                Config.load("/nonexisting").should == {:backends => ["yaml"], :hierarchy => "common", :logger => "console"}
+            end
+
             it "should use hash data as source if supplied" do
                 config = Config.load({"rspec" => "test"})
                 config["rspec"].should == "test"

data/spec/unit/console_logger_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 class Hiera
     describe Console_logger do

data/spec/unit/hiera_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe "Hiera" do
     describe "#logger=" do

metadata

@@ -1,25 +1,25 @@
 --- !ruby/object:Gem::Specification 
 name: hiera
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
-- R.I.Pienaar
+- Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-06-12 00:00:00 +01:00
-default_executable: hiera
+date: 2012-01-12 00:00:00 Z
 dependencies: []
 
 description: A pluggable data store for hierarcical data
-email: rip@devco.net
+email: info@puppetlabs.com
 executables: 
 - hiera
 extensions: []
@@ -28,14 +28,20 @@ extra_rdoc_files: []
 
 files: 
 - bin/hiera
-- lib/hiera.rb
-- lib/hiera/puppet_logger.rb
+- lib/hiera/backend/yaml_backend.rb
 - lib/hiera/backend.rb
 - lib/hiera/config.rb
 - lib/hiera/console_logger.rb
-- lib/hiera/backend/yaml_backend.rb
-has_rdoc: true
-homepage: https://github.com/ripienaar/hiera/
+- lib/hiera/puppet_logger.rb
+- lib/hiera.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/backend/yaml_backend_spec.rb
+- spec/unit/backend_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/console_logger_spec.rb
+- spec/unit/hiera_spec.rb
+homepage: https://github.com/puppetlabs/hiera/
 licenses: []
 
 post_install_message: 
@@ -44,31 +50,35 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Light weight hierarcical data store
 test_files: 
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/unit/backend/yaml_backend_spec.rb
 - spec/unit/backend_spec.rb
+- spec/unit/config_spec.rb
 - spec/unit/console_logger_spec.rb
 - spec/unit/hiera_spec.rb
-- spec/unit/config_spec.rb
-- spec/unit/backend/yaml_backend_spec.rb