hiera-puppet 0.3.0 → 1.0.0rc2

data/bin/extlookup2hiera

@@ -6,51 +6,51 @@ require 'csv'
 options = {:in => nil, :out => nil, :format => :yaml}
 
 OptionParser.new do |opts|
-    opts.banner = "Converter for extlookup CSV files into Hiera JSON and YAML files"
+  opts.banner = "Converter for extlookup CSV files into Hiera JSON and YAML files"
 
-    opts.on("--in FILE", "-i", "Input CSV file") do |v|
-        options[:in] = v
-    end
+  opts.on("--in FILE", "-i", "Input CSV file") do |v|
+    options[:in] = v
+  end
 
-    opts.on("--out FILE", "-o", "Output Hiera file") do |v|
-        options[:out] = v
-    end
+  opts.on("--out FILE", "-o", "Output Hiera file") do |v|
+    options[:out] = v
+  end
 
-    opts.on("--json", "-j", "Create JSON format file") do |v|
-        options[:format] = :json
-    end
+  opts.on("--json", "-j", "Create JSON format file") do |v|
+    options[:format] = :json
+  end
 end.parse!
 
 if options[:in].nil? || options[:out].nil?
-    STDERR.puts "Please specify an input and output file with --in and --out"
-    exit 1
+  STDERR.puts "Please specify an input and output file with --in and --out"
+  exit 1
 end
 
 unless File.exist?(options[:in])
-    STDERR.puts "Cannot find input file #{options[:in]}"
-    exit 1
+  STDERR.puts "Cannot find input file #{options[:in]}"
+  exit 1
 end
 
 csvdata = CSV.read(options[:in])
 hieradata = {}
 
 csvdata.each do |d|
-    d = d.map{|item| item.to_s}
+  d = d.map{|item| item.to_s}
 
-    if d.size > 2
-        hieradata[d[0]] = d[1, d.size].flatten
-    else
-        hieradata[d[0]] = d[1]
-    end
+  if d.size > 2
+    hieradata[d[0]] = d[1, d.size].flatten
+  else
+    hieradata[d[0]] = d[1]
+  end
 end
 
 case options[:format]
 when :yaml
-    require 'yaml'
-    File.open(options[:out], "w") {|f| f.write hieradata.to_yaml}
-
+  require 'yaml'
+  File.open(options[:out], "w") {|f| f.write hieradata.to_yaml}
 when :json
-    require 'rubygems'
-    require 'json'
-    File.open(options[:out], "w") {|f| f.write JSON.pretty_generate hieradata}
+  require 'rubygems'
+  require 'json'
+  File.open(options[:out], "w") {|f| f.write JSON.pretty_generate hieradata}
 end
+

data/lib/hiera/backend/puppet_backend.rb

@@ -1,90 +1,102 @@
 class Hiera
-    module Backend
-        class Puppet_backend
-            def initialize
-                Hiera.debug("Hiera Puppet backend starting")
-            end
+  module Backend
+    class Puppet_backend
+      def initialize
+        Hiera.debug("Hiera Puppet backend starting")
+      end
+
+      def hierarchy(scope, override)
+        begin
+          data_class = Config[:puppet][:datasource] || "data"
+        rescue
+          data_class = "data"
+        end
 
-            def hierarchy(scope, override)
-                begin
-                    data_class = Config[:puppet][:datasource] || "data"
-                rescue
-                    data_class = "data"
-                end
+        calling_class = scope.resource.name.to_s.downcase
+        calling_module = calling_class.split("::").first
 
-                calling_class = scope.resource.name.to_s.downcase
-                calling_module = calling_class.split("::").first
+        hierarchy = Config[:hierarchy] || [calling_class, calling_module]
 
-                hierarchy = Config[:hierarchy] || [calling_class, calling_module]
+        hierarchy = [hierarchy].flatten.map do |klass|
+          klass = Backend.parse_string(klass, scope,
+            {
+              "calling_class"  => calling_class,
+              "calling_module" => calling_module
+            }
+          )
 
-                hierarchy = [hierarchy].flatten.map do |klass|
-                    klass = Backend.parse_string(klass, scope, {"calling_class" => calling_class, "calling_module" => calling_module})
+          next if klass == ""
 
-                    next if klass == ""
+          [data_class, klass].join("::")
+        end.compact
 
-                    [data_class, klass].join("::")
-                end.compact
+        hierarchy << [calling_class, data_class].join("::")
 
-                hierarchy << [calling_class, data_class].join("::")
-                hierarchy << [calling_module, data_class].join("::") unless calling_module == calling_class
+        unless calling_module == calling_class
+          hierarchy << [calling_module, data_class].join("::")
+        end
 
-                hierarchy.insert(0, [data_class, override].join("::")) if override
+        hierarchy.insert(0, [data_class, override].join("::")) if override
 
-                hierarchy
-            end
+        hierarchy
+      end
+
+      def lookup(key, scope, order_override, resolution_type)
+        answer = nil
+
+        Hiera.debug("Looking up #{key} in Puppet backend")
+
+        include_class = Puppet::Parser::Functions.function(:include)
+        loaded_classes = scope.catalog.classes
 
-            def lookup(key, scope, order_override, resolution_type)
-                answer = Backend.empty_answer(resolution_type)
-
-                Hiera.debug("Looking up #{key} in Puppet backend")
-
-                include_class = Puppet::Parser::Functions.function(:include)
-                loaded_classes = scope.catalog.classes
-
-                hierarchy(scope, order_override).each do |klass|
-                    Hiera.debug("Looking for data in #{klass}")
-
-                    varname = [klass, key].join("::")
-                    temp_answer = nil
-
-                    unless loaded_classes.include?(klass)
-                        begin
-                            if scope.respond_to?(:function_include)
-                                scope.function_include(klass)
-                            else
-                                scope.real.function_include(klass)
-                            end
-
-                            temp_answer = scope[varname]
-                            Hiera.debug("Found data in class #{klass}")
-                        rescue
-                        end
-                    else
-                        temp_answer = scope[varname]
-                    end
-
-                    next if temp_answer == :undefined
-
-                    if temp_answer
-                        # 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
-                        case resolution_type
-                        when :array
-                            answer << Backend.parse_answer(temp_answer, scope)
-                        else
-                            answer = Backend.parse_answer(temp_answer, scope)
-                            break
-                        end
-                    end
-                end
-
-                answer = nil if answer == :undefined
-
-                answer
+        hierarchy(scope, order_override).each do |klass|
+          Hiera.debug("Looking for data in #{klass}")
+
+          varname = [klass, key].join("::")
+          temp_answer = nil
+
+          unless loaded_classes.include?(klass)
+            begin
+              if scope.respond_to?(:function_include)
+                scope.function_include(klass)
+              else
+                scope.real.function_include(klass)
+              end
+
+              temp_answer = scope[varname]
+              Hiera.debug("Found data in class #{klass}")
+            rescue
+            end
+          else
+            temp_answer = scope[varname]
+          end
+
+          next if temp_answer == :undefined
+
+          if temp_answer
+            # For array resolution we just append to the array whatever we
+            # find, we then go onto the next file and keep adding to the array.
+            #
+            # For priority searches we break after the first found data item.
+            case resolution_type
+            when :array
+              answer ||= []
+              answer << Backend.parse_answer(temp_answer, scope)
+            when :hash
+              answer ||= {}
+              answer = Backend.parse_answer(temp_answer, scope).merge answer
+            else
+              answer = Backend.parse_answer(temp_answer, scope)
+              break
             end
+          end
         end
+
+        answer = nil if answer == :undefined
+
+        answer
+      end
     end
+  end
 end
+

data/lib/hiera/scope.rb

@@ -1,41 +1,42 @@
 class Hiera
-    class Scope
-        attr_reader :real
-
-        def initialize(real)
-            @real = real
-        end
-
-        def [](key)
-            if key == "calling_class"
-                ans = @real.resource.name.to_s.downcase
-            elsif key == "calling_module"
-                ans = @real.resource.name.to_s.downcase.split("::").first
-            else
-                ans = @real.lookupvar(key)
-            end
-
-            # damn you puppet visual basic style variables.
-            return nil if ans == ""
-            return ans
-        end
-
-        def include?(key)
-            return true if ["calling_class", "calling_module"].include?(key)
-
-            return @real.lookupvar(key) != ""
-        end
-
-        def catalog
-            @real.catalog
-        end
-
-        def resource
-            @real.resource
-        end
-
-        def compiler
-            @real.compiler
-        end
+  class Scope
+    attr_reader :real
+
+    def initialize(real)
+      @real = real
+    end
+
+    def [](key)
+      if key == "calling_class"
+        ans = @real.resource.name.to_s.downcase
+      elsif key == "calling_module"
+        ans = @real.resource.name.to_s.downcase.split("::").first
+      else
+        ans = @real.lookupvar(key)
+      end
+
+      # damn you puppet visual basic style variables.
+      return nil if ans == ""
+      return ans
     end
-end
+
+    def include?(key)
+      return true if ["calling_class", "calling_module"].include?(key)
+
+      return @real.lookupvar(key) != ""
+    end
+
+    def catalog
+      @real.catalog
+    end
+
+    def resource
+      @real.resource
+    end
+
+    def compiler
+      @real.compiler
+    end
+  end
+end
+

data/lib/hiera_puppet.rb

@@ -0,0 +1,89 @@
+require 'hiera'
+require 'hiera/scope'
+require 'puppet'
+
+module HieraPuppet
+  module_function
+
+  def lookup(key, default, scope, override, resolution_type)
+    unless scope.respond_to?("[]")
+      scope = Hiera::Scope.new(scope)
+    end
+
+    answer = hiera.lookup(key, default, scope, override, resolution_type)
+
+    if answer.nil?
+      raise(Puppet::ParseError, "Could not find data item #{key} in any Hiera data file and no default supplied")
+    end
+
+    answer
+  end
+
+  def parse_args(args)
+    # Functions called from Puppet manifests like this:
+    #
+    #   hiera("foo", "bar")
+    #
+    # Are invoked internally after combining the positional arguments into a
+    # single array:
+    #
+    #   func = function_hiera
+    #   func(["foo", "bar"])
+    #
+    # Functions called from templates preserve the positional arguments:
+    #
+    #   scope.function_hiera("foo", "bar")
+    #
+    # Deal with Puppet's special calling mechanism here.
+    if args[0].is_a?(Array)
+      args = args[0]
+    end
+
+    if args.empty?
+      raise(Puppet::ParseError, "Please supply a parameter to perform a Hiera lookup")
+    end
+
+    key      = args[0]
+    default  = args[1]
+    override = args[2]
+
+    return [key, default, override]
+  end
+
+  private
+  module_function
+
+  def hiera
+    @hiera ||= Hiera.new(:config => hiera_config)
+  end
+
+  def hiera_config
+    config = {}
+
+    if config_file = hiera_config_file
+      config = Hiera::Config.load(config_file)
+    end
+
+    config[:logger] = 'puppet'
+    config
+  end
+
+  def hiera_config_file
+    config_file = nil
+
+    if Puppet.settings[:hiera_config].is_a?(String)
+      expanded_config_file = File.expand_path(Puppet.settings[:hiera_config])
+      if File.exist?(expanded_config_file)
+        config_file = expanded_config_file
+      end
+    elsif Puppet.settings[:confdir].is_a?(String)
+      expanded_config_file = File.expand_path(File.join(Puppet.settings[:confdir], '/hiera.yaml'))
+      if File.exist?(expanded_config_file)
+        config_file = expanded_config_file
+      end
+    end
+
+    config_file
+  end
+end
+

data/lib/puppet/parser/functions/hiera.rb

@@ -1,45 +1,8 @@
 module Puppet::Parser::Functions
-    newfunction(:hiera, :type => :rvalue) do |*args|
-        # Functions called from puppet manifests that look like this:
-        #   lookup("foo", "bar")
-        # internally in puppet are invoked:  func(["foo", "bar"])
-        #
-        # where as calling from templates should work like this:
-        #   scope.function_lookup("foo", "bar")
-        #
-        #  Therefore, declare this function with args '*args' to accept any number
-        #  of arguments and deal with puppet's special calling mechanism now:
-        if args[0].is_a?(Array)
-            args = args[0]
-        end
-
-        key = args[0]
-        default = args[1]
-        override = args[2]
-
-        configfile = File.join([File.dirname(Puppet.settings[:config]), "hiera.yaml"])
-
-        raise(Puppet::ParseError, "Hiera config file #{configfile} not readable") unless File.exist?(configfile)
-        raise(Puppet::ParseError, "You need rubygems to use Hiera") unless Puppet.features.rubygems?
-
-        require 'hiera'
-        require 'hiera/scope'
-
-        config = YAML.load_file(configfile)
-        config[:logger] = "puppet"
-
-        hiera = Hiera.new(:config => config)
-
-        if self.respond_to?("[]")
-            hiera_scope = self
-        else
-            hiera_scope = Hiera::Scope.new(self)
-        end
-
-        answer = hiera.lookup(key, default, hiera_scope, override, :priority)
-
-        raise(Puppet::ParseError, "Could not find data item #{key} in any Hiera data file and no default supplied") if answer.nil?
-
-        return answer
-    end
+  newfunction(:hiera, :type => :rvalue) do |*args|
+    require 'hiera_puppet'
+    key, default, override = HieraPuppet.parse_args(args)
+    HieraPuppet.lookup(key, default, self, override, :priority)
+  end
 end
+