enviera 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: edc085b819383c89b4f57823326b9cee64d07f9b
+  data.tar.gz: 489faf52b1a6e619e617a4ba17c00cb1313381cb
+SHA512:
+  metadata.gz: 43f0aab66b2c654872cbdc639ec67b1578880d0a3d0532d5e052265cf670aa1e1f97c875316165725ac7f2b2ad344e81034a2c6690245854c4a55ce996261cb3
+  data.tar.gz: da82472d40050b880ed9f031439009d9d154fb7208406b9fc69a98d11f005a91a149d44e3d5cd504816fc7b854dcbb503e03bfda334badbada89ba6638c83947

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'trollop'
+gem 'json'
+gem 'hiera'
+
+group :test do
+  gem "rake"
+end

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.4.2)
+    trollop (2.1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  trollop

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Tom Poulton
+Modified work Copyright (c) 2015 Josh Souza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+Enviera
+===========
+
+Enviera is a tool to go along with Puppet and Hiera that will allow you to see
+all of the variables defined within Hiera for a particular environment
+(or for Puppet, a set of facts)
+
+:new: *v0.0.1 - Created*
+
+Why it's useful
+-------------------------
+
+Hiera is a fantastic tool for separating your data from your code, particularly with Puppet. However, it serves a
+very specific purpose: Find a value in a hierarchy of files, and return the first one found. Unfortunately this
+means that it does not (nor does it entirely make sense for it to) allow you to query *all* the values that are
+available. There are, however, times when this can be very useful for troubleshooting, migrating to hiera, or
+understanding state. For example, if you wanted to know what defaults are presently would be provided to a particular
+server, were you to change a fact about it (I.E. its role), how would you determine this? Presently, by reviewing
+your hiera.yaml, and searching through your hierarchy manually.
+Enter Enviera. Compile all the facts about the machine in question, and perform a lookup. This will provide you all
+of the keys available, and their values (It shows the raw hiera values, so no worries if you're using eyaml etc...).
+You can also do a hierarchy lookup, and it will tell you which hierarchy files are being polled for your data as well.
+Hopefully this can be helpful in isolating what variables are being (or will be) assigned to your nodes.
+
+Setup
+-----
+
+### Installing Enviera
+
+    $ gem install enviera
+
+Hiera Config
+-----
+
+Unless told otherwise, Enviera will use /etc/puppet/hiera.yaml for its hiera config. You can customize this, and
+in certain events may even want to consider using a separate hiera file for your lookups (I.E. If you want to test,
+or exclude certain files)
+
+
+Configuration file for Enviera
+----------------------------
+
+Default parameters for the Enviera command line tool can be provided by creating a configuration YAML file.
+
+Config files will be read first from `/etc/enviera/config.yaml`, then from `~/.enviera/config.yaml` and finally by anything referenced in the `ENVIERA_CONFIG` environment variable
+
+The file takes any long form argument that you can provide on the command line. For example, to override the hiera config
+path:
+```yaml
+---
+hiera_config: /etc/hiera.yaml
+```
+
+Or to override to output JSON by default:
+```yaml
+---
+output: json
+```
+
+Notes
+-----
+
+Enviera will use whatever backends you have configured, but unfortunately at this time only supports
+files with a .yaml extension, and may not work properly with other backends (for determining the hierarchy).
+This means JSON or hiera-file backends for sure don't work yet.
+
+Troubleshooting
+---------------
+
+### Installing from behind a corporate/application proxy
+
+    $ export HTTP_PROXY=http://yourcorporateproxy:3128/
+    $ export HTTPS_PROXY=http://yourcorporateproxy:3128/
+
+then run your install
+
+    $ gem install enviera
+
+Examples
+-------
+
+```bash
+---
+enviera hierarchy -s '{"::fqdn": "some.host.com"}' -c "/etc/puppet/hiera.yaml" -o "yaml"
+```
+Would show all files being used in the hierarchy for the given facts, using the specified hiera config, outputting in yaml format
+
+```bash
+---
+enviera lookup -s '{"::fqdn": "some.host.com"}' -c "/etc/puppet/hiera.yaml" -m "classes" -o "json"
+```
+Would show all variables available in the hierarchy, and their values, for the given facts, using the specified hiera config, emulating the behavior of a 'hiera_include("classes")' and concatenating all results for the 'classes' parameter,
+and outputting in json
+
+Issues
+------
+
+If you have found a bug then please raise an issue on the github page.
+
+
+Tests
+-----
+
+I don't have any yet. I'm very new to the Ruby gem concept, but should get something eventually
+
+Kudos
+-----
+
+My hat is off to [Tom Poulton](http://github.com/TomPoulton) for the [hiera-eyaml](https://github.com/TomPoulton/hiera-eyaml) project, which I have mimicked the file structure of this project on. Without his incredibly clean, consise, and
+well architected code it would have taken me much longer to figure out how to make a command-line gem.
+
+Authors
+-------
+
+- [Josh Souza](http://github.com/joshsouza) - Author.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/enviera

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'enviera/CLI'
+
+begin
+  Enviera::CLI.parse
+rescue StandardError => e
+  Enviera::Utils.warn e.message
+  Enviera::Utils.debug e.backtrace.join("\n")
+  exit 1
+end
+
+begin
+  Enviera::CLI.execute
+rescue StandardError => e
+  Enviera::Utils.warn e.message
+  Enviera::Utils.debug e.backtrace.join("\n")
+  exit 1
+end

data/enviera.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'enviera'
+
+Gem::Specification.new do |gem|
+  gem.name          = "enviera"
+  gem.version       = Enviera::VERSION
+  gem.description   = "Puppet tool for looking up all Hiera values for a given set of facts"
+  gem.summary       = "Given an environment, looks up Hiera data about it. Env(ironment H)iera(chy)"
+  gem.author        = "Josh Souza"
+  gem.email         = "development@pureinsomnia.com"
+  gem.license       = "MIT"
+
+  gem.homepage      = "http://github.com/josh.souza/enviera"
+  gem.files         = `git ls-files`.split($/).reject { |file| file =~ /^features.*$/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency('trollop', '~> 2.0')
+  gem.add_dependency('json', '~> 1.5')
+  gem.add_dependency('hiera', '~> 1.3')
+end

data/lib/enviera/CLI.rb

@@ -0,0 +1,53 @@
+require 'enviera'
+require 'enviera/utils'
+require 'enviera/options'
+require 'enviera/subcommand'
+require 'trollop'
+
+module Enviera
+  class CLI
+
+    def self.parse
+
+      Utils.require_dir 'enviera/subcommands'
+      Enviera.subcommands = Utils.find_all_subclasses_of({ :parent_class => Enviera::Subcommands }).collect {|classname| Utils.snakecase classname}
+
+      Enviera.subcommand = ARGV.shift
+      subcommand = case Enviera.subcommand
+      when nil
+        ARGV.delete_if {true}
+        "unknown_command"
+      when /^\-/
+        ARGV.delete_if {true}
+        "help"
+      else
+        Enviera.subcommand
+      end
+
+      command_class = Subcommand.find subcommand
+
+      options = command_class.parse
+      options[:executor] = command_class
+
+      options = command_class.validate options
+      Enviera::Options.set options
+      Enviera::Options.trace
+
+    end
+
+    def self.execute
+
+      executor = Enviera::Options[:executor]
+      begin
+        result = executor.execute
+        puts result unless result.nil?
+      rescue Exception => e
+        Utils.warn e.message
+        Utils.debug e.backtrace.join("\n")
+      end
+
+    end
+
+  end
+
+end

data/lib/enviera/commands.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+
+module Enviera
+  class Commands
+
+    @@commands = []
+
+    def self.register
+
+    end
+
+    def self.commands
+      @@commands
+    end
+
+  end
+end

data/lib/enviera/options.rb

@@ -0,0 +1,36 @@
+
+module Enviera
+  class Options
+
+    def self.[]= key, value
+      @@options ||= {}
+      @@options[ key.to_sym ] = value
+    end
+
+    def self.[] key
+      @@options ||= {}
+      @@options[ key.to_sym ]
+    end
+
+    def self.set hash
+      @@options = {}
+      hash.each do |k, v|
+        @@options[ k.to_sym ] = v
+      end
+    end
+
+    def self.trace
+      Utils::trace "Dump of enviera tool options dict:"
+      Utils::trace "--------------------------------"
+      @@options.each do |k, v|
+        begin
+          Utils::trace sprintf "%18s %-18s = %18s %-18s", "(#{k.class.name})", k.to_s, "(#{v.class.name})", v.to_s
+        rescue
+          Utils::trace sprintf "%18s %-18s = %18s %-18s", "(#{k.class.name})", k.to_s, "(#{v.class.name})", "<unprintable>" # case where v is binary
+        end
+      end
+      Utils::trace "--------------------------------"
+    end
+
+  end
+end

data/lib/enviera/subcommand.rb

@@ -0,0 +1,136 @@
+require 'base64'
+require 'yaml'
+# require 'enviera/subcommands/unknown_command'
+
+module Enviera
+
+  class Subcommand
+
+    class << self
+      attr_accessor :global_options, :options, :helptext
+    end
+
+    @@global_options = [
+       {:name          => :version,
+          :description => "Show version information"},
+       {:name          => :verbose,
+          :description => "Be more verbose",
+          :short       => 'v'},
+       {:name          => :help,
+          :description => "Information on how to use this command",
+          :short       => 'h'}
+      ]
+
+    def self.load_config_file
+      config = {}
+      [ "/etc/enviera/config.yaml", "#{ENV['HOME']}/.enviera/config.yaml", "#{ENV['ENVIERA_CONFIG']}" ].each do |config_file|
+        begin
+          yaml_contents = YAML.load_file(config_file)
+          Utils::info "Loaded config from #{config_file}"
+          config.merge! yaml_contents
+        rescue
+          raise StandardError, "Could not open config file \"#{config_file}\" for reading"
+        end if config_file and File.file? config_file
+      end
+      config
+    end
+
+    def self.all_options
+      options = @@global_options.dup
+      options += self.options if self.options
+      # merge in defaults from configuration files
+      config_file = self.load_config_file
+      options.map!{ | opt|
+        key_name = "#{opt[:name]}"
+        if config_file.has_key? key_name
+          opt[:default] = config_file[key_name]
+          opt
+        else
+          opt
+        end
+      }
+      options
+    end
+
+    def self.attach_option opt
+      self.suboptions += opt
+    end
+
+    def self.find commandname = "unknown_command"
+      begin
+        require "enviera/subcommands/#{commandname.downcase}"
+      rescue Exception => e
+        require "enviera/subcommands/unknown_command"
+        return Enviera::Subcommands::UnknownCommand
+      end
+      command_module = Module.const_get('Enviera').const_get('Subcommands')
+      command_class = Utils.find_closest_class :parent_class => command_module, :class_name => commandname
+      command_class || Enviera::Subcommands::UnknownCommand
+    end
+
+    def self.parse
+
+      me = self
+
+      options = Trollop::options do
+
+        version "Enviera version " + Enviera::VERSION.to_s
+        banner ["enviera #{me.prettyname}: #{me.description}", me.helptext, "Options:"].compact.join("\n\n")
+
+        me.all_options.each do |available_option|
+
+          skeleton = {:description => "",
+                      :short => :none}
+
+          skeleton.merge! available_option
+          opt skeleton[:name],
+              skeleton[:desc] || skeleton[:description],  #legacy plugins
+              :short => skeleton[:short],
+              :default => skeleton[:default],
+              :type => skeleton[:type]
+
+        end
+
+        stop_on Enviera.subcommands
+
+      end
+
+      if options[:verbose]
+        Enviera.verbosity_level += 1
+      end
+
+      if options[:quiet]
+        Enviera.verbosity_level = 0
+      end
+
+      options
+
+    end
+
+    def self.validate args
+      args
+    end
+
+    def self.description
+      "no description"
+    end
+
+    def self.helptext
+      "Usage: enviera #{self.prettyname} [options]"
+    end
+
+    def self.execute
+      raise StandardError, "This command is not implemented yet (#{self.to_s.split('::').last})"
+    end
+
+    def self.prettyname
+      Utils.snakecase self.to_s.split('::').last
+    end
+
+    def self.hidden?
+      false
+    end
+
+  end
+
+end

data/lib/enviera/subcommands/help.rb

@@ -0,0 +1,39 @@
+require 'enviera/subcommand'
+require 'enviera'
+
+module Enviera
+  module Subcommands
+
+    class Help < Subcommand
+
+      def self.options
+        []
+      end
+
+      def self.description
+        "this page"
+      end
+
+      def self.execute
+
+        puts <<-EOS
+Welcome to enviera #{Enviera::VERSION}
+Usage:
+enviera subcommand [global-opts] [subcommand-opts]
+Available subcommands:
+#{Enviera.subcommands.collect {|command|
+  command_class = Subcommands.const_get(Utils.camelcase command)
+  sprintf "%15s: %-65s", command.downcase, command_class.description unless command_class.hidden?
+}.compact.join("\n")}
+For more help on an individual command, use --help on that command
+EOS
+      end
+
+      def self.hidden?
+        true
+      end
+
+    end
+
+  end
+end

data/lib/enviera/subcommands/hierarchy.rb

@@ -0,0 +1,93 @@
+require 'enviera'
+require 'enviera/utils'
+require 'enviera/options'
+require 'enviera/subcommand'
+require 'hiera'
+require 'json'
+
+module Enviera
+  module Subcommands
+
+    class Hierarchy < Subcommand
+
+      def self.options
+        [{:name => :string,
+          :description => "Source input is a json string provided as an argument",
+          :short => 's',
+          :type => :string},
+         {:name => :file,
+          :description => "Source input is a regular json file",
+          :short => 'f',
+          :type => :string},
+         {:name => :stdin,
+          :description => "Source input is taken from stdin (json string)",
+          :short => :none},
+         {:name => :hiera_config,
+          :description => "Path to your hiera config yaml file",
+          :short => 'c',
+          :type => :string,
+          :default => '/etc/puppet/hiera.yaml'},
+         {:name => :output,
+          :description => "What format to output in. [json|yaml|block]",
+          :short => 'o',
+          :type => :string,
+          :default => 'yaml'}
+        ]
+      end
+
+      def self.description
+        "display the hierarchy in use with the given environment"
+      end
+
+      def self.validate options
+        sources = [:string, :file, :stdin].collect {|x| x if options[x]}.compact
+        Trollop::die "You must specify a source (I.E. -s '{}')" if sources.count.zero?
+        Trollop::die "You can only specify one of (#{sources.join(', ')})" if sources.count > 1
+        options[:source] = sources.first
+
+        options[:input_data] = case options[:source]
+        when :stdin
+          STDIN.read
+        when :string
+          options[:string]
+        when :file
+          File.read options[:file]
+        end
+        options
+      end
+
+      def self.execute
+        begin
+          environment = JSON.parse(Enviera::Options[:input_data])
+        rescue
+          raise "Unable to parse input as valid JSON. Please ensure structure is proper."
+        end
+        hiera_config = Hiera::Config.load(Enviera::Options[:hiera_config])
+        hiera= Hiera.new(:config=>hiera_config)
+        sources = []
+        hiera.config[:backends].each do |backend|
+          Hiera::Backend.datasources(environment) { |source|
+            # Presently I'm only handling 'yaml' extensions. I hope someday this works for other stuff
+            # But I haven't figured out a smart way to do this with the tools available
+            # And it's not urgent for me
+            sourcefile = Hiera::Backend.datafile(backend,environment,source,"yaml") or next
+            sources.push(sourcefile)
+          }
+        end
+        sources = {'hierarchy' => sources}
+        case Enviera::Options[:output]
+        when "block"
+          sources
+        when "json"
+          sources.to_json
+        when "yaml"
+          sources.to_yaml
+        else
+          sources.to_yaml
+        end
+      end
+
+    end
+
+  end
+end

data/lib/enviera/subcommands/lookup.rb

@@ -0,0 +1,106 @@
+require 'enviera'
+require 'enviera/utils'
+require 'enviera/options'
+require 'enviera/subcommand'
+require 'hiera'
+require 'json'
+
+module Enviera
+  module Subcommands
+
+    class Lookup < Subcommand
+
+      def self.options
+        [{:name => :string,
+          :description => "Source input is a json string provided as an argument",
+          :short => 's',
+          :type => :string},
+         {:name => :file,
+          :description => "Source input is a regular json file",
+          :short => 'f',
+          :type => :string},
+         {:name => :stdin,
+          :description => "Source input is taken from stdin (json string)",
+          :short => :none},
+         {:name => :hiera_config,
+          :description => "Path to your hiera config yaml file",
+          :short => 'c',
+          :type => :string,
+          :default => '/etc/puppet/hiera.yaml'},
+         {:name => :merged_keys,
+          :description => "Keys that should be merged (i.e. hiera_include style) separated by commas",
+          :short => 'm',
+          :type => :string,
+          :default => ''},
+         {:name => :output,
+          :description => "What format to output in. [json|yaml|block]",
+          :short => 'o',
+          :type => :string,
+          :default => 'yaml'}
+        ]
+      end
+
+      def self.description
+        "lookup hiera data for environment"
+      end
+
+      def self.validate options
+        sources = [:string, :file, :stdin].collect {|x| x if options[x]}.compact
+        Trollop::die "You must specify a source (I.E. -s '{}')" if sources.count.zero?
+        Trollop::die "You can only specify one of (#{sources.join(', ')})" if sources.count > 1
+        options[:source] = sources.first
+
+        options[:input_data] = case options[:source]
+        when :stdin
+          STDIN.read
+        when :string
+          options[:string]
+        when :file
+          File.read options[:file]
+        end
+        options
+      end
+
+      def self.execute
+        begin
+          environment = JSON.parse(Enviera::Options[:input_data])
+        rescue
+          raise "Unable to parse input as valid JSON. Please ensure structure is proper."
+        end
+        keys_to_merge = Enviera::Options[:merged_keys].split(',')
+        hiera_config = Hiera::Config.load(Enviera::Options[:hiera_config])
+        hiera= Hiera.new(:config=>hiera_config)
+        keys = {}
+        hiera.config[:backends].each do |backend|
+          Hiera::Backend.datasources(environment) { |source|
+            # Presently I'm only handling 'yaml' extensions. I hope someday this works for other stuff
+            # But I haven't figured out a smart way to do this with the tools available
+            # And it's not urgent for me
+            sourcefile = Hiera::Backend.datafile(backend,environment,source,"yaml") or next
+            source = YAML.load_file(sourcefile)
+            source.each_key do |key|
+              if !keys.has_key?(key) then
+                keys[key] = source[key]
+              elsif keys_to_merge.include?(key) then
+                keys[key] = (keys[key] + source[key]).uniq
+              end
+            end
+          }
+        end
+        keys = keys.sort.to_h
+        case Enviera::Options[:output]
+        when "block"
+          keys
+        when "json"
+          keys.to_json
+        when "yaml"
+          keys.to_yaml
+        else
+          keys.to_yaml
+        end
+      end
+
+    end
+
+  end
+end

data/lib/enviera/subcommands/unknown_command.rb

@@ -0,0 +1,42 @@
+require 'enviera/subcommand'
+
+module Enviera
+  module Subcommands
+
+    class UnknownCommand < Enviera::Subcommand
+
+      class << self
+        attr_accessor :original_command
+      end
+
+      @@original_command = "unknown"
+
+      def self.options
+        []
+      end
+
+      def self.description
+        "Unknown command (#{@@original_command})"
+      end
+
+      def self.execute
+        subcommands = Enviera.subcommands
+        puts <<-EOS
+Unknown subcommand#{ ": " + Enviera.subcommand if Enviera.subcommand }
+Usage: enviera <subcommand>
+Please use one of the following subcommands or help for more help:
+  #{Enviera.subcommands.sort.collect {|command|
+  command_class = Subcommands.const_get(Utils.camelcase command)
+  command unless command_class.hidden?
+}.compact.join(", ")}
+EOS
+      end
+
+      def self.hidden?
+        true
+      end
+
+    end
+
+  end
+end

data/lib/enviera/subcommands/version.rb

@@ -0,0 +1,27 @@
+require 'enviera/subcommand'
+require 'enviera'
+
+module Enviera
+  module Subcommands
+
+    class Version < Subcommand
+
+      def self.options
+        []
+      end
+
+      def self.description
+        "show version information"
+      end
+
+      def self.execute
+        Enviera::Utils.info "enviera (core): #{Enviera::VERSION}"
+
+        nil
+
+      end
+
+    end
+
+  end
+end

data/lib/enviera/utils.rb

@@ -0,0 +1,124 @@
+
+module Enviera
+  class Utils
+
+    def self.read_password
+      ask("Enter password: ") {|q| q.echo = "*" }
+    end
+
+    def self.confirm? message
+      result = ask("#{message} (y/N): ")
+      if result.downcase == "y" or result.downcase == "yes"
+        true
+      else
+        false
+      end
+    end
+
+    def self.camelcase string
+      return string if string !~ /_/ && string =~ /[A-Z]+.*/
+      string.split('_').map{|e| e.capitalize}.join
+    end
+
+    def self.snakecase string
+      return string if string !~ /[A-Z]/
+      string.split(/(?=[A-Z])/).collect {|x| x.downcase}.join("_")
+    end
+
+    def self.find_closest_class args
+      parent_class = args[ :parent_class ]
+      class_name = args[ :class_name ]
+      constants = parent_class.constants
+      candidates = []
+      constants.each do | candidate |
+        candidates << candidate.to_s if candidate.to_s.downcase == class_name.downcase
+      end
+      if candidates.count > 0
+        parent_class.const_get candidates.first
+      else
+        nil
+      end
+    end
+
+    def self.require_dir classdir
+      num_class_hierarchy_levels = self.to_s.split("::").count - 1
+      root_folder = File.dirname(__FILE__) + "/" + Array.new(num_class_hierarchy_levels).fill("..").join("/")
+      class_folder = root_folder + "/" + classdir
+      Dir[File.expand_path("#{class_folder}/*.rb")].uniq.each do |file|
+        self.trace "Requiring file: #{file}"
+        require file
+      end
+    end
+
+    def self.find_all_subclasses_of args
+      parent_class = args[ :parent_class ]
+      constants = parent_class.constants
+      candidates = []
+      constants.each do | candidate |
+        candidates << candidate.to_s.split('::').last if parent_class.const_get(candidate).class.to_s == "Class"
+      end
+      candidates
+    end
+
+    def self.structure_message messageinfo
+      message = {:from => "enviera-core"}
+      case messageinfo.class.to_s
+      when 'Hash'
+        message.merge!(messageinfo)
+      else
+        message.merge!({:msg => messageinfo.to_s})
+      end
+      message[:prefix] = "[#{message[:from]}]"
+      message[:spacer] = " #{' ' * message[:from].length} "
+      formatted_output = message[:msg].split("\n").each_with_index.map do |line, index|
+        if index == 0
+          "#{message[:prefix]} #{line}"
+        else
+          "#{message[:spacer]} #{line}"
+        end
+      end
+      formatted_output.join "\n"
+    end
+
+    def self.warn messageinfo
+      self.print_message({ :message => self.structure_message( messageinfo ), :enviera_loglevel => :warn, :cli_color => :red })
+    end
+
+    def self.info messageinfo
+      self.print_message({ :message => self.structure_message( messageinfo ), :enviera_loglevel => :debug, :cli_color => :white, :threshold => 0 })
+    end
+
+    def self.debug messageinfo
+      self.print_message({ :message => self.structure_message( messageinfo ), :enviera_loglevel => :debug, :cli_color => :green, :threshold => 1 })
+    end
+
+    def self.trace messageinfo
+      self.print_message({ :message => self.structure_message( messageinfo ), :enviera_loglevel => :debug, :cli_color => :blue, :threshold => 2 })
+    end
+
+    def self.print_message( args )
+      message        = args[:message] ||= ""
+      enviera_loglevel = args[:enviera_loglevel] ||= :debug
+      cli_color      = args[:cli_color] ||= :blue
+      threshold      = args[:threshold]
+
+      STDERR.puts self.colorize( message, cli_color ) if threshold.nil? or Enviera.verbosity_level > threshold
+    end
+
+    def self.colorize message, color
+      suffix = "\e[0m"
+      prefix = case color
+      when :red
+        "\e[31m"
+      when :green
+        "\e[32m"
+      when :blue
+        "\e[34m"
+      else #:white
+        "\e[0m"
+      end
+      "#{prefix}#{message}#{suffix}"
+    end
+
+  end
+end

data/lib/enviera.rb

@@ -0,0 +1,32 @@
+module Enviera
+  VERSION = "0.0.1"
+  DESCRIPTION = "Enviera is a tool for looking up all Hiera values available based on a given set of puppet facts"
+
+  class RecoverableError < StandardError
+  end
+
+  def self.subcommand= command
+    @@subcommand = command
+  end
+
+  def self.subcommand
+    @@subcommand
+  end
+
+  def self.verbosity_level= new_verbosity_level
+    @@debug_level = new_verbosity_level
+  end
+
+  def self.verbosity_level
+    @@debug_level ||= 1
+    @@debug_level
+  end
+
+  def self.subcommands= commands
+    @@subcommands = commands
+  end
+
+  def self.subcommands
+    @@subcommands
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: enviera
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Josh Souza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: hiera
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Puppet tool for looking up all Hiera values for a given set of facts
+email: development@pureinsomnia.com
+executables:
+- enviera
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/enviera
+- enviera.gemspec
+- lib/enviera.rb
+- lib/enviera/CLI.rb
+- lib/enviera/commands.rb
+- lib/enviera/options.rb
+- lib/enviera/subcommand.rb
+- lib/enviera/subcommands/help.rb
+- lib/enviera/subcommands/hierarchy.rb
+- lib/enviera/subcommands/lookup.rb
+- lib/enviera/subcommands/unknown_command.rb
+- lib/enviera/subcommands/version.rb
+- lib/enviera/utils.rb
+homepage: http://github.com/josh.souza/enviera
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Given an environment, looks up Hiera data about it. Env(ironment H)iera(chy)
+test_files: []
+has_rdoc: