hiera 0.3.0 → 1.0.0rc4

data/bin/hiera

@@ -11,159 +11,163 @@
 #
 # $ hiera release 'rel/%{location}' location=dc2 --yaml some.node.yaml
 
-require 'rubygems'
+begin
+  require 'rubygems'
+rescue LoadError
+end
 require 'hiera'
+require 'hiera/util'
 require 'optparse'
 
-options = {:default => nil, :config => "/etc/hiera.yaml", :scope => {}, :key => nil, :verbose => false, :resolution_type => :priority}
-
-class Hiera::Noop_logger
-    class << self
-        def warn(msg);end
-        def debug(msg);end
-    end
-end
+options = {
+  :default => nil,
+  :config  => File.join(Hiera::Util.config_dir, 'hiera.yaml'),
+  :scope   => {},
+  :key     => nil,
+  :verbose => false,
+  :resolution_type => :priority
+}
 
 # Loads the scope from YAML or JSON files
 def load_scope(source, type=:yaml)
-    case type
-    when :mcollective
-        begin
-            require 'mcollective'
-
-            include MCollective::RPC
-
-            util = rpcclient("rpcutil")
-            util.progress = false
-            nodestats = util.custom_request("inventory", {}, source, {"identity" => source}).first
-
-            raise "Failed to retrieve facts for node #{source}: #{nodestats[:statusmsg]}" unless nodestats[:statuscode] == 0
-
-            scope = nodestats[:data][:facts]
-        rescue Exception => e
-            STDERR.puts "MCollective lookup failed: #{e.class}: #{e}"
-            exit 1
-        end
-
-    when :yaml
-        raise "Cannot find scope #{type} file #{source}" unless File.exist?(source)
-
-        require 'yaml'
-
-        # Attempt to load puppet in case we're going to be fed
-        # Puppet yaml files
-        begin
-            require 'puppet'
-        rescue
-        end
-
-        scope = YAML.load_file(source)
-
-        # 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
+  case type
+  when :mcollective
+    begin
+      require 'mcollective'
 
-    raise "Scope from #{type} file #{source} should be a Hash" unless scope.is_a?(Hash)
+      include MCollective::RPC
 
-    scope
-end
+      util = rpcclient("rpcutil")
+      util.progress = false
+      nodestats = util.custom_request("inventory", {}, source, {"identity" => source}).first
 
-OptionParser.new do |opts|
-    opts.on("--version", "-V", "Version information") do
-        puts Hiera.version
-        exit
-    end
+      raise "Failed to retrieve facts for node #{source}: #{nodestats[:statusmsg]}" unless nodestats[:statuscode] == 0
 
-    opts.on("--debug", "-d", "Show debugging information") do
-        options[:verbose] = true
+      scope = nodestats[:data][:facts]
+    rescue Exception => e
+      STDERR.puts "MCollective lookup failed: #{e.class}: #{e}"
+      exit 1
     end
 
-    opts.on("--array", "-a", "Array search") do
-        options[:resolution_type] = :array
-    end
+  when :yaml
+    raise "Cannot find scope #{type} file #{source}" unless File.exist?(source)
 
-    opts.on("--hash", "-h", "Hash search") do
-        options[:resolution_type] = :hash
-    end
+    require 'yaml'
 
-    opts.on("--config CONFIG", "-c", "Configuration file") do |v|
-        if File.exist?(v)
-            options[:config] = v
-        else
-            STDERR.puts "Cannot find config file: #{v}"
-            exit 1
-        end
+    # Attempt to load puppet in case we're going to be fed
+    # Puppet yaml files
+    begin
+        require 'puppet'
+    rescue
     end
 
-    opts.on("--json SCOPE", "-j", "JSON format file to load scope from") do |v|
-        begin
-            options[:scope] = load_scope(v, :json)
-        rescue Exception => e
-            STDERR.puts "Could not load JSON scope: #{e.class}: #{e}"
-            exit 1
-        end
+    scope = YAML.load_file(source)
+
+    # 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
 
-    opts.on("--yaml SCOPE", "-y", "YAML format file to load scope from") do |v|
-        begin
-            options[:scope] = load_scope(v)
-        rescue Exception => e
-            STDERR.puts "Could not load YAML scope: #{e.class}: #{e}"
-            exit 1
-        end
-    end
+  raise "Scope from #{type} file #{source} should be a Hash" unless scope.is_a?(Hash)
 
-    opts.on("--mcollective IDENTITY", "-m", "Retrieve facts from a node via mcollective as scope") do |v|
-        begin
-            options[:scope] = load_scope(v, :mcollective)
-        rescue Exception => e
-            STDERR.puts "Could not load MCollective scope: #{e.class}: #{e}"
-            exit 1
-        end
-    end
+  scope
+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
+OptionParser.new do |opts|
+  opts.on("--version", "-V", "Version information") do
+    puts Hiera.version
+    exit
+  end
+
+  opts.on("--debug", "-d", "Show debugging information") do
+    options[:verbose] = true
+  end
+
+  opts.on("--array", "-a", "Array search") do
+    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
+    else
+      STDERR.puts "Cannot find config file: #{v}"
+      exit 1
+    end
+  end
+
+  opts.on("--json SCOPE", "-j", "JSON format file to load scope from") do |v|
+    begin
+      options[:scope] = load_scope(v, :json)
+    rescue Exception => e
+      STDERR.puts "Could not load JSON scope: #{e.class}: #{e}"
+      exit 1
+    end
+  end
+
+  opts.on("--yaml SCOPE", "-y", "YAML format file to load scope from") do |v|
+    begin
+      options[:scope] = load_scope(v)
+    rescue Exception => e
+      STDERR.puts "Could not load YAML scope: #{e.class}: #{e}"
+      exit 1
+    end
+  end
+
+  opts.on("--mcollective IDENTITY", "-m", "Retrieve facts from a node via mcollective as scope") do |v|
+    begin
+      options[:scope] = load_scope(v, :mcollective)
+    rescue Exception => e
+      STDERR.puts "Could not load MCollective scope: #{e.class}: #{e}"
+      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:
@@ -172,43 +176,43 @@ end.parse!
 #
 # The var=val's assign scope
 unless ARGV.empty?
-    options[:key] = ARGV.delete_at(0)
-
-    ARGV.each do |arg|
-        if arg =~ /^(.+?)=(.+?)$/
-            options[:scope][$1] = $2
-        else
-            unless options[:default]
-                options[:default] = arg.dup
-            else
-                STDERR.puts "Don't know how to parse scope argument: #{arg}"
-            end
-        end
+  options[:key] = ARGV.delete_at(0)
+
+  ARGV.each do |arg|
+    if arg =~ /^(.+?)=(.+?)$/
+      options[:scope][$1] = $2
+    else
+      unless options[:default]
+        options[:default] = arg.dup
+      else
+        STDERR.puts "Don't know how to parse scope argument: #{arg}"
+      end
     end
+  end
 else
-    STDERR.puts "Please supply a data item to look up"
-    exit 1
+  STDERR.puts "Please supply a data item to look up"
+  exit 1
 end
 
 begin
-    hiera = Hiera.new(:config => options[:config])
+  hiera = Hiera.new(:config => options[:config])
 rescue Exception => e
-    if options[:verbose]
-        raise
-    else
-        STDERR.puts "Failed to start Hiera: #{e.class}: #{e}"
-        exit 1
-    end
+  if options[:verbose]
+    raise
+  else
+    STDERR.puts "Failed to start Hiera: #{e.class}: #{e}"
+    exit 1
+  end
 end
 
 unless options[:verbose]
-    Hiera.logger = "noop"
+  Hiera.logger = "noop"
 end
 
 ans = hiera.lookup(options[:key], options[:default], options[:scope], nil, options[:resolution_type])
 
 if ans.is_a?(String)
-    puts ans
+  puts ans
 else
-    p ans
+  p ans
 end

data/lib/hiera.rb

@@ -1,61 +1,69 @@
-require 'rubygems'
+begin
+  require 'rubygems'
+rescue LoadError
+end
 require 'yaml'
 
 class Hiera
-    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
-            VERSION
-        end
-
-        # Loggers are pluggable, just provide a class called
-        # Hiera::Foo_logger and respond to :warn and :debug
-        #
-        # See hiera-puppet for an example that uses the Puppet
-        # loging system instead of our own
-        def logger=(logger)
-            loggerclass = "#{logger.capitalize}_logger"
-
-            require "hiera/#{logger}_logger" unless constants.include?(loggerclass)
-
-            @logger = const_get(loggerclass)
-        rescue Exception => e
-            @logger = Console_logger
-            warn("Failed to load #{logger} logger: #{e.class}: #{e}")
-        end
-
-        def warn(msg); @logger.warn(msg); end
-        def debug(msg); @logger.debug(msg); end
-    end
+  VERSION = "1.0.0"
 
-    attr_reader :options, :config
+  autoload :Config,         "hiera/config"
+  autoload :Util,           "hiera/util"
+  autoload :Backend,        "hiera/backend"
+  autoload :Console_logger, "hiera/console_logger"
+  autoload :Puppet_logger,  "hiera/puppet_logger"
+  autoload :Noop_logger,    "hiera/noop_logger"
 
-    # If the config option is a string its assumed to be a filename,
-    # else a hash of what would have been in the YAML config file
-    def initialize(options={})
-        options[:config] ||= "/etc/hiera.yaml"
+  class << self
+    attr_reader :logger
 
-        @config = Config.load(options[:config])
-
-        Config.load_backends
+    def version
+      VERSION
     end
 
-    # Calls the backends to do the actual lookup.
-    #
-    # The scope can be anything that responds to [], if you have input
-    # data like a Puppet Scope that does not you can wrap that data in a
-    # class that has a [] method that fetches the data from your source.
-    # See hiera-puppet for an example of this.
+    # Loggers are pluggable, just provide a class called
+    # Hiera::Foo_logger and respond to :warn and :debug
     #
-    # The order-override will insert as first in the hierarchy a data source
-    # of your choice.
-    def lookup(key, default, scope, order_override=nil, resolution_type=:priority)
-        Backend.lookup(key, default, scope, order_override, resolution_type)
+    # See hiera-puppet for an example that uses the Puppet
+    # loging system instead of our own
+    def logger=(logger)
+      loggerclass = "#{logger.capitalize}_logger"
+
+      require "hiera/#{logger}_logger" unless constants.include?(loggerclass)
+
+      @logger = const_get(loggerclass)
+    rescue Exception => e
+      @logger = Console_logger
+      warn("Failed to load #{logger} logger: #{e.class}: #{e}")
     end
+
+    def warn(msg); @logger.warn(msg); end
+    def debug(msg); @logger.debug(msg); end
+  end
+
+  attr_reader :options, :config
+
+  # If the config option is a string its assumed to be a filename,
+  # else a hash of what would have been in the YAML config file
+  def initialize(options={})
+    options[:config] ||= File.join(Util.config_dir, 'hiera.yaml')
+
+    @config = Config.load(options[:config])
+
+    Config.load_backends
+  end
+
+  # Calls the backends to do the actual lookup.
+  #
+  # The scope can be anything that responds to [], if you have input
+  # data like a Puppet Scope that does not you can wrap that data in a
+  # class that has a [] method that fetches the data from your source.
+  # See hiera-puppet for an example of this.
+  #
+  # The order-override will insert as first in the hierarchy a data source
+  # of your choice.
+  def lookup(key, default, scope, order_override=nil, resolution_type=:priority)
+    Backend.lookup(key, default, scope, order_override, resolution_type)
+  end
 end
+