jerakia 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e7a0ffdcc717ef8705465da1d89d701353e31a4d
+  data.tar.gz: a40d224bb84863097b2b1e4d877aa5b8bfbed9c7
+SHA512:
+  metadata.gz: a1e2f422baea90e6bc37df8bd5ed1b9717b41a3968b4eb44ad50dfa80eb1defdc11461da6f57e749fd074d4a986a9f135ea9ddee6797fcd9a73ef14dcca0e9b5
+  data.tar.gz: a6f211698de9b7286b674e76285f9720bc7c50a70f5bb9d9d121610592fae36ecf5d0bb858fdaf54ea7268d3108f93f322514a5f4cefbe8d963b02ac9c61d931

data/bin/jerakia

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'jerakia'
+require 'json'
+require 'optparse'
+
+options = {
+  :policy       => "default",
+  :config       => "/etc/jerakia/jerakia.yml",
+  :scope        => nil,
+  :key          => nil,
+  :merge        => "array",
+  :lookup_type  => "first",
+  :namespace    => nil,
+  :metadata     => {},
+}
+
+OptionParser.new do |opts|
+
+  opts.on("--config CONFIG","-c","Config file") do |c|
+    options[:config] = c
+  end
+
+  opts.on("--key KEY", "-k", "Lookup key") do |k|
+    options[:key] = k
+  end
+
+  opts.on("--policy POLICY", "-p", "Policy") do |p|
+    options[:policy] = p.to_sym
+  end
+
+  opts.on("--namespace NAMESPACE", "-n", "Namespace") do |n|
+    options[:namespace] = n.split(/::/)
+  end
+
+  opts.on("--type TYPE", "-t", "Lookup type") do |t|
+    options[:lookup_type] = t.to_sym
+  end
+
+  opts.on("--scope SCOPE", "-s", "Scope handler") do |s|
+    options[:scope] = s.to_sym
+  end
+
+  opts.on("--merge MERGE", "-m", "Merge type") do |m|
+    options[:merge] = m.to_sym
+  end
+end.parse!
+
+unless ARGV.empty?
+  ARGV.each do |arg|
+    meta=arg.split(':')
+    options[:metadata][meta[0]] = meta[1]
+  end
+end
+
+
+
+jac = Jerakia.new({:config => options[:config]})
+req = Jerakia::Request.new(
+  :key => options[:key],
+  :namespace => options[:namespace],
+  :policy => options[:policy].to_sym,
+  :lookup_type => options[:lookup_type].to_sym,
+  :merge       => options[:merge].to_sym,
+  :loglevel    => 'debug',
+  :metadata => options[:metadata]
+) 
+
+
+answer = jac.lookup(req)
+puts answer.payload.to_json

data/lib/hiera/backend/jerakia_backend.rb

@@ -0,0 +1,67 @@
+class Hiera
+  module Backend
+    class Jerakia_backend
+
+      def initialize
+        require 'jerakia'
+        @config = Config[:jerakia] || {}
+        @policy = @config[:policy] || 'default'
+        @jerakia = ::Jerakia.new(Config[:jerakia] || {}) 
+        Jerakia.log.debug("[hiera] hiera backend loaded with policy #{@policy}")
+
+      end
+
+        
+      def lookup(key, scope, order_override, resolution_type)
+
+
+        lookup_type = :first
+        merge_type = :none
+        
+        case resolution_type
+        when :array
+          lookup_type = :cascade
+          merge_type = :array
+        when :hash
+          lookup_type = :cascade
+          merge_type = :hash
+        end
+
+        namespace = []
+
+        if key.include?('::')
+           lookup_key = key.split('::')
+           namespace << lookup_key.shift
+           key = lookup_key.join('::')
+        end
+
+        Jerakia.log.debug("[hiera] backend invoked for key #{key} using namespace #{namespace}")
+          
+        metadata={}
+        if scope.is_a?(Hash)
+          metadata=scope
+        else
+          metadata = scope.real.to_hash
+        end
+
+
+        request = Jerakia::Request.new(
+          :key =>      key,
+          :namespace   => namespace,
+          :policy      => @policy,
+          :lookup_type => lookup_type,
+          :merge       => merge_type,
+          :metadata    => metadata,
+        )
+ 
+        answer = @jerakia.lookup(request)
+        answer.payload
+     
+
+      end
+    end
+  end
+end
+
+
+

data/lib/jerakia/answer.rb

@@ -0,0 +1,36 @@
+class Jerakia::Answer
+
+  attr_accessor :payload
+  attr_accessor :datatype
+  attr_reader :lookup_type
+
+  def initialize(lookup_type = :first)
+    case lookup_type
+    when :first
+      @payload=nil
+    when :cascade
+      @payload=[]
+      @datatype="array"
+    end
+  end
+
+  def flatten_payload!
+    @payload.flatten!
+  end
+
+  def merge_payload!
+    payload_hash={}
+    @payload.each do |p|
+      if p.is_a?(Hash)
+        payload_hash.merge!(p)
+      end
+    end
+    @payload=payload_hash
+    set_data_type
+  end
+
+  def set_data_type
+    @data_type=@payload.class.to_s.downcase
+  end
+end
+

data/lib/jerakia/cache.rb

@@ -0,0 +1,24 @@
+#
+# Very primitive form of cache - but we'll make this smarter
+#
+#
+class Jerakia::Cache
+
+  def initialize
+    @@bucket = {}
+  end
+
+  def bucket_add(index,data)
+    @@bucket[index] = data
+    data
+  end
+
+  def in_bucket?(index)
+    @@bucket.has_key?(index)
+  end
+
+  def bucket
+    @@bucket
+  end
+end
+

data/lib/jerakia/config.rb

@@ -0,0 +1,25 @@
+class Jerakia::Config
+
+  require 'yaml'
+  attr_reader :policydir
+  attr_reader :server_url
+
+  def initialize(config='/etc/jerakia/jerakia.yml')
+    unless File.exists?(config)
+      Jerakia.crit("Config file #{config} not found")
+    end
+    rawdata=File.read(config)
+    ymldata=YAML.load(rawdata)
+    @policydir=ymldata['policydir']
+    @server_url=ymldata['server_url']
+    @configdata=ymldata
+  end
+
+  def [](key)
+    @configdata[key.to_s]
+  end
+
+
+end
+
+

data/lib/jerakia/datamodel.rb

@@ -0,0 +1,9 @@
+class Jerakia::Datamodel < Jerakia
+
+  
+  def initialize
+    @@namespace = {}
+  end
+
+end
+

data/lib/jerakia/datasource/dummy.rb

@@ -0,0 +1,17 @@
+class Jerakia::Datasource
+  module Dummy
+
+    def run
+      #
+      # Do the lookup
+
+      Jerakia.log.debug("Searching key #{lookup.request.key} in dummy datasource")
+      option :return, { :type => String, :default => "Returned data" }  
+      response.submit options[:return]
+      
+
+      
+    end
+  end
+end
+

data/lib/jerakia/datasource/file/yaml.rb

@@ -0,0 +1,17 @@
+class Jerakia::Datasource
+  module File
+    class Yaml
+      class << self
+      require 'yaml'
+      def import_file(fname, extension='yml')
+        diskfile="#{fname}.#{extension}"
+        Jerakia.log.debug("scanning file #{diskfile}")
+        return {} unless ::File.exists?(diskfile)
+        data=::File.read(diskfile)
+        YAML.load(data)
+      end
+      end
+    end
+  end
+end
+

data/lib/jerakia/datasource/file.rb

@@ -0,0 +1,65 @@
+class Jerakia::Datasource
+  module File
+
+    attr_reader :file_format
+    def load_format_handler
+      format = options[:format] || :yaml
+      class_name=format.to_s.capitalize
+      require "jerakia/datasource/file/#{format.to_s}"
+      @file_format = eval "Jerakia::Datasource::File::#{class_name}"
+    end
+
+    def read_from_file(fname)
+      fpath = []
+      fpath << options[:docroot] unless fname[0] == '/'
+      fpath << [ fname, lookup.request.namespace ]
+      diskname = ::File.join(fpath.flatten).gsub(/\/$/, '')
+
+      Jerakia.log.debug("read_from_file() #{fname} using diskname #{diskname}")
+
+      import_args=[]
+      import_args << diskname
+      import_args << options[:extension] if options[:extension]
+
+      cache_index={ :diskname => diskname, :format => options[:format] }
+      if options[:enable_caching]
+        if in_bucket?(cache_index) 
+          Jerakia.log.debug("returning cached data #{bucket[cache_index]}")
+          bucket[cache_index]
+        else
+          Jerakia.log.debug("adding to cache #{@file_format.import_file(*import_args)}")
+          bucket_add(cache_index,@file_format.import_file(*import_args))
+        end
+      else
+        @file_format.import_file(*import_args)
+      end
+    end
+
+
+    def run
+      #
+      # Do the lookup
+
+      Jerakia.log.debug("Searching key #{lookup.request.key} from file format #{options[:format]} (#{whoami})")
+      option :searchpath, { :type => Array,  :mandatory => true }
+      option :format,     { :type => Symbol, :default => :yaml }
+      option :docroot,    { :type => String, :default => "/etc/jerakia/data" }
+      option :extension,  { :type => String }
+
+      load_format_handler
+
+      options[:searchpath].each do |path|
+        Jerakia.log.debug("Attempting to load data from #{path}")
+        return unless response.want?
+        data=read_from_file(path)
+        Jerakia.log.debug("Datasource provided #{data} looking for key #{lookup.request.key}")
+        if data[lookup.request.key]
+          Jerakia.log.debug("Found data #{data[lookup.request.key]}")
+          response.submit data[lookup.request.key]
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/jerakia/datasource.rb

@@ -0,0 +1,39 @@
+require 'jerakia/cache'
+class Jerakia::Datasource < Jerakia::Cache
+
+  require 'jerakia/response'
+  attr_reader :response
+  attr_reader :options
+  attr_reader :lookup
+
+  def initialize(name, lookup, opts)
+    @response = Jerakia::Response.new(lookup)
+    @options = opts
+    @lookup = lookup
+    @name = name
+    require "jerakia/datasource/#{name.to_s}"
+    # rescue loaderrer
+    eval "extend Jerakia::Datasource::#{name.to_s.capitalize}"
+  end
+
+
+  ## used for verbose logging
+  def whoami
+    "datasource=#{@name}  lookup=#{@lookup.name}"
+  end
+
+  def option(opt, data={})
+    @options[opt] ||= data[:default] || nil
+    Jerakia.log.debug("[#{whoami}]: options[#{opt}] to #{options[opt]} [#{options[opt].class}]")
+    if @options[opt].nil?
+      Jerakia.crit "#{opt} must be configured in #{whoami}" if data[:mandatory]
+    else 
+      if data[:type]
+        Jerakia.crit "#{opt} must be a #{data[:type].to_s} in #{whoami}" unless @options[opt].is_a?(data[:type])
+      end
+    end
+  end
+    
+          
+end
+

data/lib/jerakia/launcher.rb

@@ -0,0 +1,34 @@
+# Here we take a request object and read in the policy file
+# which is evalulated in this instance
+#
+class Jerakia::Launcher
+
+  attr_reader :request
+  attr_reader :answer
+  def initialize(req)
+    @@request = req
+    invoke
+  end
+
+  def invoke
+    policy_name=request.policy.to_s
+    Jerakia.log.info "Invoked lookup for #{@@request.key} using policy #{policy_name}"
+    filename=File.join(Jerakia.config.policydir, "#{policy_name}.rb")
+    policydata=Jerakia.filecache(filename)
+    instance_eval policydata
+  end
+
+  def request
+    @@request
+  end
+
+
+  def policy(name, opts={},  &block)
+    policy = Jerakia::Policy.new(name, opts, &block)
+    policy.fire!
+    @answer = policy.answer
+  end
+end
+
+
+

data/lib/jerakia/log.rb

@@ -0,0 +1,52 @@
+class Jerakia::Log < Jerakia
+
+  require 'logger'
+  def initialize(level=:info)
+    @@logfile ||= config[:logfile] || '/var/log/jerakia.log'
+    @@logger ||= Logger.new(@@logfile)
+    @@level ||= level
+    case @@level
+    when :info
+      @@logger.level = Logger::INFO
+    when :debug
+      @@logger.level = Logger::DEBUG
+    end
+  end
+
+  def info(msg)
+    @@logger.info msg
+  end
+
+  def debug(msg)
+    @@logger.debug msg
+  end
+
+  def error(msg)
+    @@logger.error msg
+  end
+
+  def fatal(msg)
+    @@logger.fatal msg
+  end
+
+#  def self.fatal(msg)
+#    self.new.fatal msg
+#  end 
+#
+#  def self.error(msg)
+#    self.new.error msg
+#  end
+#
+  def self.debug(msg)
+    self.new.debug msg
+  end
+#
+##  def self.info(msg)
+#    puts @@logger
+#    self.new.info msg
+#  end
+
+
+
+end
+

data/lib/jerakia/lookup.rb

@@ -0,0 +1,92 @@
+class Jerakia::Lookup
+  require 'jerakia/datasource'
+  require 'jerakia/scope'
+  require 'jerakia/plugins/lookup/hiera_compat'
+  require 'jerakia/plugins/lookup/confine'
+
+  attr_accessor :request
+  attr_reader :datasource
+  attr_reader :valid
+  attr_reader :lookuptype
+  attr_reader :scope_object
+  attr_reader :output_filters
+  attr_reader :name
+  attr_reader :proceed
+
+  def initialize(name,req,scope,&block)
+    
+    @name=name
+    @request=req
+    @valid=true
+    @scope_object=scope
+    @output_filters=[]
+    @proceed=true
+    extend Jerakia::Lookup::Plugin
+    instance_eval &block
+    
+  end
+
+  def datasource(source, opts={})
+    @datasource = Jerakia::Datasource.new(source, self, opts)
+  end
+
+  # If set, Jerakia will pass each Jerakia::Response object
+  # to an output filter plugin
+  #
+
+  def scope
+    @scope_object.value
+  end
+
+
+  def output_filter(name,opts={})
+    @output_filters << { :name => name, :opts => opts }
+  end
+    
+  def proceed?
+    @proceed
+  end
+
+  ## lookup function: stop
+  # Enabling stop sets @proceed to false, which will cause Jerakia
+  # *not* to load any more lookups in the policy if this lookup is
+  # deemed as valid.  If the lookup is invalidated than Jerakia *will*
+  # progress to the next lookup.   This is useful in conjuction with
+  # the confine plugin where we want to segregate some lookups but
+  # not worry about excluding from later lookups
+  #
+  def stop
+    @proceed = false
+  end
+
+  ## lookup function: continue
+  # Will cause Jerakia to continue to the next lookup in the policy
+  # which is the default behaviour
+  #
+  def continue
+    @proceed = true
+  end
+
+  ## lookup function: invalidate
+  # Setting invalidate will mean this lookup will be skipped in the policy
+  #
+  def invalidate
+    @valid=false
+  end
+
+  def valid?
+    return @valid
+  end
+
+  def run
+    @datasource.run
+    response=@datasource.response
+    @output_filters.each do |filter|
+      response.filter! filter[:name], filter[:opts]
+    end
+    return response
+  end
+
+
+end
+

data/lib/jerakia/plugins/lookup/confine.rb

@@ -0,0 +1,20 @@
+class Jerakia::Lookup
+  module Plugin
+
+    def confine(key=nil,match)
+      if key
+        invalidate unless key[Regexp.new(match)] == key
+      else
+        invalidate
+      end
+    end
+
+    def exclude(key=nil,match)
+      if key
+        invalidate if key[Regexp.new(match)] == key
+      end
+    end
+      
+  end
+end
+

data/lib/jerakia/plugins/lookup/hiera_compat.rb

@@ -0,0 +1,26 @@
+# This plugin reformats the lookup key according to a puppet's
+# Hiera system, so instead of looking up <key> in <path>/<namespace>.yml
+# we lookup <namespace>::<key> in <path>.yml
+#
+# This is a useful plugin for people wanting to test drive Jerakia
+# but maintain an existing hiera filesystem layout and naming convention
+# within the source data.
+#
+class Jerakia::Lookup
+  module Plugin
+    def hiera_compat
+      request.key.prepend("#{request.namespace.join('::')}::")
+      request.namespace=[]
+    end
+
+    def calling_module
+      if request.namespace.length > 0
+        request.namespace[0]
+      else
+        Jerakia.log.error("hiera_compat plugin tried to use calling_module but there is no namespace declared.  Ensure that calling_module is called before hiera_compat in the policy")
+      end
+    end
+  end
+end
+
+

data/lib/jerakia/policy.rb

@@ -0,0 +1,65 @@
+require 'jerakia/launcher'
+
+class Jerakia::Policy < Jerakia::Launcher
+  require 'jerakia/answer'
+
+  attr_accessor :lookups
+  attr_reader   :routes
+  attr_reader   :answer
+  attr_reader   :scope
+  attr_reader   :lookup_proceed
+
+  def initialize(name, opts, &block)
+    @lookups=[]
+    @routes={}
+    @answer=Jerakia::Answer.new(request.lookup_type)
+    @scope=Jerakia::Scope.new
+    @lookup_proceed = true    
+    begin
+      instance_eval &block
+    rescue => e
+      Jerakia.fatal "Error processing policy file", e
+    end
+  end
+
+  def clone_request
+    Marshal.load(Marshal.dump(request))
+  end
+
+
+  def lookup(name,opts={},&block)
+    # We specifically clone the request object to allow plugins to modify the
+    # request payload for the scope of this lookup only.
+    #
+    lookup = Jerakia::Lookup.new(name,clone_request,scope,&block)
+    Jerakia.log.debug("Proceed to next lookup #{lookup.proceed?}")
+   
+    @lookups << lookup if lookup.valid? and @lookup_proceed
+    @lookup_proceed = false if !lookup.proceed? and lookup.valid?
+
+  end
+
+  def fire!
+    @lookups.each do |l|
+      responses = l.run
+      responses.entries.each do |res|
+        case request.lookup_type
+        when :first
+          @answer.payload ||= res[:value]
+          @answer.datatype ||= res[:datatype]
+        when :cascade
+          @answer.payload << res[:value]
+        end
+      end
+
+      if request.lookup_type == :cascade && @answer.payload.is_a?(Array) && request.merge == :array
+        @answer.flatten_payload!
+      end
+      if request.lookup_type == :cascade && @answer.payload.is_a?(Array) && request.merge == :hash
+        @answer.merge_payload!
+      end
+
+    end
+  end
+end
+

data/lib/jerakia/request.rb

@@ -0,0 +1,21 @@
+class Jerakia::Request
+
+  attr_accessor :key
+  attr_accessor :namespace
+  attr_accessor :merge
+  attr_accessor :policy
+  attr_accessor :metadata
+  attr_accessor :lookup_type
+  attr_accessor :scope
+
+  def initialize(opts={})
+    @key = opts[:key] || ''
+    @namespace =  opts[:namespace] || []
+    @merge = opts[:merge] || false
+    @policy = opts[:policy] || 'default'
+    @metadata = opts[:metadata] || {}
+    @lookup_type = opts[:lookup_type] || :first
+    @scope = opts[:scope] || nil
+  end
+
+end