hieracles 0.0.1

data/lib/hieracles/formats/csv.rb

@@ -0,0 +1,66 @@
+module Hieracles
+  module Formats
+    # for db compatibility
+    class Csv < Hieracles::Format
+      CVS_DELIM = ';'
+
+      def info(_)
+        make_csv @node.info.values
+      end
+
+      def files(_)
+        make_csv @node.files
+      end
+
+      def paths(_)
+        make_csv @node.paths
+      end
+
+      def build_head(without_common)
+        output = []
+        @node.files(without_common).each do |f|
+          output << f
+        end
+        output += %w(var value overriden)
+        make_csv output
+      end
+
+      def build_params_line(key, value, filter)
+        output = ''
+        if !filter || Regexp.new(filter).match(key)
+          first = value.shift
+          output << make_csv(in_what_file(first[:file]) +
+                   [key, first[:value].to_s, '0'])
+          while value.count > 0
+            overriden = value.shift
+            output << make_csv(in_what_file(overriden[:file]) +
+                     [key, overriden[:value].to_s, '1'])
+          end
+        end
+        output
+      end
+
+      def build_modules_line(key, value)
+        make_csv [key, value]
+      end
+
+    private
+
+      def make_csv(array)
+        array.join(CVS_DELIM) + "\n"
+      end
+
+      def in_what_file(file)
+        output = []
+        @node.files.each do |f|
+          if file == f
+            output << '1'
+          else
+            output << '0'
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/hieracles/formats/plain.rb

@@ -0,0 +1,61 @@
+module Hieracles
+  module Formats
+    # format accepting colors
+    # for display in the terminal
+    class Plain < Hieracles::Format
+      include Hieracles::Utils
+
+      def initialize(node)
+        @index = {}
+        super(node)
+      end
+
+      def info(_)
+        back = ''
+        length = max_key_length(@node.info) + 2
+        @node.info.each do |k, v|
+          back << format("%-#{length}s %s\n", k, v)
+        end
+        back
+      end
+
+      def files(_)
+        @node.files.join("\n") + "\n"
+      end
+
+      def paths(_)
+        @node.paths.join("\n") + "\n"
+      end
+
+      def build_head(without_common)
+        output = ''
+        @node.files(without_common).each_with_index do |f, i|
+          output << "[#{i}] #{f}\n"
+          @index[f] = i
+        end
+        "#{output}\n"
+      end
+
+      def build_params_line(key, value, filter)
+        output = ''
+        if !filter || Regexp.new(filter).match(key)
+          first = value.shift
+          filecolor_index = @index[first[:file]]
+          output << "[#{filecolor_index}] #{key} #{first[:value]}\n"
+          while value.count > 0
+            overriden = value.shift
+            filecolor_index = @index[overriden[:file]]
+            output << "    [#{filecolor_index}] #{key} #{overriden[:value]}\n"
+          end
+        end
+        output
+      end
+
+      def build_modules_line(key, value)
+        length = max_key_length(@node.modules) + 3
+        format("%-#{length}s %s\n", key, value)
+      end
+
+    end
+  end
+end

data/lib/hieracles/formats/yaml.rb

@@ -0,0 +1,36 @@
+module Hieracles
+  module Formats
+    # format mostly useful for re-integration in param files
+    class Yaml < Hieracles::Format
+
+      def info(_)
+        @node.info.to_yaml
+      end
+
+      def files(_)
+        @node.files.to_yaml
+      end
+
+      def paths(_)
+        @node.paths.to_yaml
+      end
+
+      def modules(_)
+        @node.modules.to_yaml
+      end
+
+      def params(args)
+        @node.params_tree(true).to_yaml
+      end
+
+      def allparams(args)
+        @node.params_tree(false).to_yaml
+      end
+
+      def modules(args)
+        @node.modules.to_yaml
+      end
+
+    end
+  end
+end

data/lib/hieracles/help.rb

@@ -0,0 +1,27 @@
+module Hieracles
+  module Help
+
+    def self.usage
+      return <<-END
+
+      Usage: hc <fqdn> <command> [extra_args]
+
+      Available commands:
+        info        provides the farm, datacenter, country
+                    associated to the given fqdn
+        files       list all files containing params affecting this fqdn
+                    (in more than commons)
+        paths       list all file paths for files with params
+        modules     list modules included in the farm where the node is
+        params      list params for the node matching the fqdn
+                    An extra filter string can be added to limit the list
+                    use ruby regexp without the enclosing slashes
+                    eg. hc <fqdn> params postfix.*version
+                    eg. hc <fqdn> params '^postfix'
+                    eg. hc <fqdn> params 'version$'
+        allparams   same as params but including the common.yaml params (huge)
+                    Also accepts a search string
+      END
+    end
+  end
+end

data/lib/hieracles/hiera.rb

@@ -0,0 +1,27 @@
+module Hieracles
+
+  class Hiera
+
+    def initialize
+      raise IOError, "Hierafile #{Config.hierafile} not found." unless File.exist? Config.path('hierafile')
+      @hierafile = Config.path('hierafile')
+      @loaded = YAML.load_file(@hierafile)
+    end
+
+    def datadir
+      raise TypeError, "Sorry hieracles only knows yaml backend for now." unless @loaded[:yaml]
+      parampath = File.expand_path(File.join(Config.basepath, @loaded[:yaml][:datadir]))
+      raise IOError, "Params dir #{parampath} not found." unless Dir.exist? parampath
+      parampath
+    end
+
+    def hierarchy
+      @loaded[:hierarchy]
+    end
+
+    def params
+      hierarchy.join(',').scan(/%\{(?:::)?([^\}]*)\}/).flatten.uniq
+    end
+
+  end
+end

data/lib/hieracles/node.rb

@@ -0,0 +1,108 @@
+require "net/http"
+require "uri"
+require "yaml"
+
+module Hieracles
+  class Node
+    include Hieracles::Utils
+
+    attr_reader :hiera_params, :hiera
+
+    def initialize(fqdn, options)
+      Config.load(options)
+      @hiera = Hieracles::Hiera.new
+      @hiera_params = { fqdn: fqdn }.
+        merge(get_hiera_params(fqdn)).
+        merge(Config.extraparams)
+      @fqdn = fqdn
+    end
+
+    def get_hiera_params(fqdn)
+      if File.exist?(File.join(Config.path('encpath'), "#{fqdn}.yaml"))
+        load = YAML.load_file(File.join(Config.path('encpath'), "#{fqdn}.yaml"))
+        sym_keys(load['parameters'])
+      else
+        raise "Node not found"
+      end
+    end
+
+    def files(without_common = true)
+      @hiera.hierarchy.reduce([]) do |a, f|
+        file = format("#{f}.yaml", @hiera_params) rescue nil
+        if file && 
+           File.exist?(File.join(@hiera.datadir, file)) &&
+           (!without_common ||
+           !file[/common/])
+          a << file
+        end
+        a
+      end
+    end
+
+    def paths(without_common = true)
+      files(without_common).map { |p| File.join(@hiera.datadir, p) }
+    end
+
+    def params(without_common = true)
+      params = {}
+      files(without_common).each do |f|
+        data = YAML.load_file(File.join(@hiera.datadir, f))
+        s = to_shallow_hash(data)
+        s.each do |k,v|
+          params[k] ||= []
+          params[k] << { value: v, file: f}
+        end
+      end
+      params.sort
+    end
+
+    def params_tree(without_common = true)
+      params = {}
+      paths(without_common).each do |f|
+        data = YAML.load_file(f)
+        deep_merge!(params, data)
+      end
+      deep_sort(params)
+    end
+
+    def modules
+     if File.exist?(classfile)
+        modules = {}
+        f = File.open(classfile, "r")
+        f.each_line do |line|
+          modules = add_modules(line, modules)
+        end
+        f.close
+        modules
+      else
+        raise "Class file #{classfile} not found."
+      end
+    end
+
+    def info
+      @hiera_params
+    end
+
+    def classfile
+      format(Config.path('classpath'), @hiera_params[:farm])
+    end
+
+    def modulepath(path)
+      File.join(Config.path('modulepath'), path)
+    end
+
+    def add_modules(line, modules)
+      if /^\s*include\s*([-_:a-zA-Z0-9]*)\s*/.match(line)
+        mod = $1
+        mainmod = mod[/^[^:]*/]
+        if Dir.exists? modulepath(mainmod)
+          modules[mod] = File.join(Config.modulepath, mainmod)
+        else
+          modules[mod] = nil
+        end
+      end
+      modules
+    end
+
+  end
+end

data/lib/hieracles/optparse.rb

@@ -0,0 +1,63 @@
+module Hieracles
+
+  class Optparse
+    
+    attr_reader :options, :payload
+
+    OPTIONS = {
+      config: {
+        has_arg: true,
+        aliases: ['c', 'conf', 'config']
+      },
+      format: {
+        has_arg: true,
+        aliases: ['f', 'format']
+      },
+      params: {
+        has_arg: true,
+        aliases: ['p', 'params']
+      },
+      hierafile: {
+        has_arg: true,
+        aliases: ['h', 'hierafile']
+      },
+      basepath: {
+        has_arg: true,
+        aliases: ['b', 'basepath']
+      },
+      encpath: {
+        has_arg: true,
+        aliases: ['e', 'encpath']
+      }
+    }
+
+    def initialize(array)
+      @options = {}
+      @payload = []
+      ok = optionkeys
+      while x = array.shift
+        if x[0] == '-'
+          if ok[x[/[a-z][-_a-z]*$/]]
+            @options[ok[x[/[a-z][-_a-z]*$/]]] = array.shift
+          else
+            array.shift
+          end
+        else
+          @payload << x
+        end
+      end
+    end
+
+    def optionkeys
+      back = {}
+      OPTIONS.each do |k, v|
+        v[:aliases].each do |a|
+          back[a] = k
+        end
+      end
+      back
+    end
+
+  end
+
+end

data/lib/hieracles/utils.rb

@@ -0,0 +1,59 @@
+module Hieracles
+  module Utils
+
+    def to_shallow_hash(hash)
+      hash.reduce({}) do |shallow_hash, (key, value)|
+        if value.is_a?(Hash)
+          to_shallow_hash(value).each do |sub_key, sub_value|
+            shallow_hash[[key, sub_key].join('.')] = sub_value
+          end
+        else
+          shallow_hash[key.to_s] = value
+        end
+        shallow_hash
+      end
+    end
+
+    def to_deep_hash(hash)
+      hash.reduce({}) do |a, (key, value)|
+        keys = key.to_s.split('.').reverse
+        leaf_key = keys.shift
+        key_hash = keys.reduce(leaf_key.to_sym => value) { |h, k| { k.to_sym => h } }
+        deep_merge!(a, key_hash)
+        a
+      end
+    end
+    
+    def deep_merge!(hash1, hash2)
+      merger = proc { |key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2 }
+      hash1.merge!(hash2, &merger)
+    end
+
+    def deep_sort(object)
+      if object.is_a?(Hash)
+        res = {}
+        object.each { |k, v| res[k] = deep_sort(v) }
+        Hash[res.sort { |a, b| a[0].to_s <=> b[0].to_s }]
+      elsif object.is_a?(Array)
+        if object[0].is_a?(Hash) || object[0].is_a?(Array)
+          array = []
+          object.each_with_index { |v, i| array[i] = deep_sort(v) }
+          array
+        else
+          object.sort
+        end
+      else
+        object
+      end
+    end
+
+    def max_key_length(hash)
+      hash.keys.reduce(0) { |a, x| (x.length > a) ? x.length : a }
+    end
+
+    def sym_keys(hash)
+      hash.reduce({}) { |a, (k, v)| a[k.to_sym] = v ; a }
+    end
+
+  end
+end