hiera 0.1.0

data/bin/hiera

@@ -0,0 +1,143 @@
+#!/bin/env ruby
+
+# CLI client for Hiera.
+#
+# To lookup the 'release' key for a node given Puppet YAML facts:
+#
+# $ hiera release 'rel/%{location}' --yaml some.node.yaml
+#
+# If the node yaml had a location fact the default would match that
+# else you can supply scope values on the command line
+#
+# $ hiera release 'rel/%{location}' location=dc2 --yaml some.node.yaml
+
+require 'rubygems'
+require 'hiera'
+require 'optparse'
+
+
+options = {:default => nil, :config => "/etc/hiera.yaml", :scope => {}, :key => nil, :verbose => false}
+
+class Hiera::Noop_logger
+    class << self
+        def warn(msg);end
+        def debug(msg);end
+    end
+end
+
+# Loads the scope from YAML or JSON files
+def load_scope(file, type=:yaml)
+    raise "Cannot find scope #{type} file #{file}" unless File.exist?(file)
+
+    case type
+    when :yaml
+        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(file)
+
+        # Puppet makes dumb yaml files that do not promote data reuse.
+        scope = scope.values if scope.is_a?(Puppet::Node::Facts)
+    when :json
+        require 'json'
+
+        scope = JSON.load(File.read(file))
+    else
+        raise "Don't know how to load data type #{type}"
+    end
+
+    raise "Scope from #{type} file #{file} should be a Hash" unless scope.is_a?(Hash)
+
+    scope
+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("--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
+end.parse!
+
+# arguments can be:
+#
+# key default var=val another=val
+#
+# 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
+    end
+else
+    STDERR.puts "Please supply a data item to look up"
+    exit 1
+end
+
+begin
+    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
+end
+
+unless options[:verbose]
+    Hiera.logger = "noop"
+end
+
+ans = hiera.lookup(options[:key], options[:default], options[:scope])
+
+if ans.is_a?(String)
+    puts ans
+else
+    p ans
+end

data/lib/hiera.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'yaml'
+
+class Hiera
+    VERSION = "0.1.0"
+
+    autoload :Config, "hiera/config"
+    autoload :Backend, "hiera/backend"
+    autoload :Console_logger, "hiera/console_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
+
+    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] ||= "/etc/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.
+    #
+    # 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
+end

data/lib/hiera/backend.rb

@@ -0,0 +1,102 @@
+class Hiera
+    module Backend
+        class << self
+            # Data lives in /var/lib/hiera by default.  If a backend
+            # supplies a datadir in the config it will be used and
+            # subject to variable expansion based on scope
+            def datadir(backend, scope)
+                backend = backend.to_sym
+                default = "/var/lib/hiera"
+
+                if Config.include?(backend)
+                    parse_string(Config[backend][:datadir] || default, scope)
+                else
+                    parse_string(default, scope)
+                end
+            end
+
+            # Constructs a list of data sources to search
+            #
+            # If you give it a specific hierarchy it will just use that
+            # else it will use the global configured one, failing that
+            # it will just look in the 'common' data source.
+            #
+            # An override can be supplied that will be pre-pended to the
+            # hierarchy.
+            #
+            # The source names will be subject to variable expansion based
+            # on scope
+            def datasources(scope, override=nil, hierarchy=nil)
+                if hierarchy
+                    hierarchy = [hierarchy]
+                elsif Config.include?(:hierarchy)
+                    hierarchy = [Config[:hierarchy]].flatten
+                else
+                    hierarchy = ["common"]
+                end
+
+                hierarchy.insert(0, override) if override
+
+                hierarchy.flatten.map do |source|
+                    source = parse_string(source, scope)
+                    yield(source) unless source == ""
+                end
+            end
+
+            # Parse a string like '%{foo}' against a supplied
+            # scope and additional scope.  If either scope or
+            # extra_scope includes the varaible 'foo' it will
+            # be replaced else an empty string will be placed.
+            #
+            # If both scope and extra_data has "foo" scope
+            # will win.  See hiera-puppet for an example of
+            # this to make hiera aware of additional non scope
+            # variables
+            def parse_string(data, scope, extra_data={})
+                return nil unless data
+
+                tdata = data.clone
+
+                if tdata.is_a?(String)
+                    while tdata =~ /%\{(.+?)\}/
+                        var = $1
+                        val = scope[var] || extra_data[var] || ""
+
+                        tdata.gsub!(/%\{#{var}\}/, val)
+                    end
+                end
+
+                return tdata
+            end
+
+            # Calls out to all configured backends in the order they
+            # were specified.  The first one to answer will win.
+            #
+            # This lets you declare multiple backends, a possible
+            # use case might be in Puppet where a Puppet module declares
+            # default data using in-module data while users can override
+            # using JSON/YAML etc.  By layering the backends and putting
+            # the Puppet one last you can override module author data
+            # easily.
+            #
+            # Backend instances are cached so if you need to connect to any
+            # databases then do so in your constructor, future calls to your
+            # backend will not create new instances
+            def lookup(key, default, scope, order_override, resolution_type)
+                @backends ||= {}
+                answer = nil
+
+                Config[:backends].each do |backend|
+                    if constants.include?("#{backend.capitalize}_backend")
+                        @backends[backend] ||= Backend.const_get("#{backend.capitalize}_backend").new
+                        answer = @backends[backend].lookup(key, scope, order_override, resolution_type)
+
+                        break if answer
+                    end
+                end
+
+                answer || parse_string(default, scope)
+            end
+        end
+    end
+end

data/lib/hiera/backend/yaml_backend.rb

@@ -0,0 +1,45 @@
+class Hiera
+    module Backend
+        class Yaml_backend
+            def initialize
+                require 'yaml'
+
+                Hiera.debug("Hiera YAML backend starting")
+            end
+
+            def lookup(key, scope, order_override, resolution_type)
+                answer = nil
+
+                Hiera.debug("Looking up #{key} in YAML backend")
+
+                datadir = Backend.datadir(:yaml, scope)
+
+                raise "Cannot find data directory #{datadir}" unless File.directory?(datadir)
+
+                Backend.datasources(scope, order_override) do |source|
+                    unless answer
+                        Hiera.debug("Looking for data source #{source}")
+
+                        datafile = File.join([datadir, "#{source}.yaml"])
+
+                        unless File.exist?(datafile)
+                            Hiera.warn("Cannot find datafile #{datafile}, skipping")
+                            next
+                        end
+
+                        data = YAML.load_file(datafile)
+
+                        next if data.empty?
+                        next unless data.include?(key)
+
+                        answer = Backend.parse_string(data[key], scope)
+                    else
+                        break
+                    end
+                end
+
+                answer
+            end
+        end
+    end
+end

data/lib/hiera/config.rb

@@ -0,0 +1,50 @@
+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.merge! YAML.load_file(source)
+            elsif source.is_a?(Hash)
+                @config.merge! source
+            end
+
+            @config[:backends] = [ @config[:backends] ].flatten
+
+            if @config.include?(:logger)
+                Hiera.logger = @config[:logger].to_s
+            else
+                @config[:logger] = "console"
+                Hiera.logger = "console"
+            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
+        end
+
+        def include?(key)
+            @config.include?(key)
+        end
+
+        def [](key)
+            @config[key]
+        end
+    end
+end

data/lib/hiera/console_logger.rb

@@ -0,0 +1,13 @@
+class Hiera
+    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
+    end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: hiera
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- R.I.Pienaar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-05 00:00:00 +01:00
+default_executable: hiera
+dependencies: []
+
+description: A pluggable data store for hierarcical data
+email: rip@devco.net
+executables: 
+- hiera
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/hiera
+- lib/hiera.rb
+- lib/hiera/backend.rb
+- lib/hiera/config.rb
+- lib/hiera/console_logger.rb
+- lib/hiera/backend/yaml_backend.rb
+has_rdoc: true
+homepage: http://devco.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Light weight hierarcical data store
+test_files: []
+