jerakia 1.1.2 → 1.2.0

data/lib/jerakia/log.rb

@@ -1,7 +1,6 @@
 class Jerakia::Log < Jerakia
-
   require 'logger'
-  def initialize(level=:info,file='/var/log/jerakia.log')
+  def initialize(level = :info, file = '/var/log/jerakia.log')
     begin
       @@logger ||= Logger.new(file)
     rescue Errno::EACCES => e
@@ -19,6 +18,10 @@ class Jerakia::Log < Jerakia
     end
   end
 
+  def logger
+    @@logger
+  end
+
   def verbose(msg)
     @@logger.info msg if @@level == :verbose
   end
@@ -39,24 +42,20 @@ class Jerakia::Log < Jerakia
     @@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
-
-
-
+  #  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/plugin/hiera.rb

@@ -8,16 +8,15 @@
 #
 class Jerakia::Lookup::Plugin
   module Hiera
-
     def autorun
-      if request.namespace.length > 0
+      unless request.namespace.empty?
         request.key.prepend("#{request.namespace.join('::')}::")
       end
-      request.namespace=[]
+      request.namespace = []
     end
 
     def rewrite_lookup
-      Jerakia.log.debug("DEPRECATION NOTICE: The use of plugin.hiera.rewrite_lookup is now deprecated and is automatically executed when the plugin is loaded")
+      Jerakia.log.debug('DEPRECATION NOTICE: The use of plugin.hiera.rewrite_lookup is now deprecated and is automatically executed when the plugin is loaded')
     end
 
     def calling_module

data/lib/jerakia/lookup/plugin.rb

@@ -1,16 +1,17 @@
 class Jerakia::Lookup::Plugin
-
-
   attr_reader :lookup
- 
-  def initialize(lookup)
+  attr_reader :config
+
+  def initialize(lookup, config)
     @lookup = lookup
+    @config = config
   end
 
   def activate(name)
     instance_eval "extend Jerakia::Lookup::Plugin::#{name.to_s.capitalize}"
   end
 
+
   def scope
     lookup.scope
   end
@@ -18,6 +19,4 @@ class Jerakia::Lookup::Plugin
   def request
     lookup.request
   end
-
 end
-

data/lib/jerakia/lookup/plugin_config.rb

@@ -0,0 +1,31 @@
+# Jerakia::Lookup::PluginConfig
+#
+# This class is a simple wrapper class to expose configuration options
+# from the global configuration file to lookup plugins.  It's exposed
+# to the lookup as the config method.  Eg: config[:foo]
+#
+class Jerakia
+  class Lookup
+    class PluginConfig
+
+      attr_reader :plugin_name
+      attr_reader :config
+
+      def initialize(plugin_name)
+        @plugin_name = plugin_name
+        @config = {}
+        if Jerakia.config[:plugins].is_a?(Hash)
+          @config = Jerakia.config[:plugins][plugin_name.to_s] || {}
+        end
+      end
+
+      def [](key)
+        config[key.to_s]
+      end
+
+    end
+  end
+end
+        
+
+

data/lib/jerakia/lookup/pluginfactory.rb

@@ -1,38 +1,32 @@
 class Jerakia::Lookup::PluginFactory
-
-   def initialize 
-     Jerakia.log.debug("Loaded plugin handler")
-     @plugin_config = Jerakia.config[:plugins] || {}
-   end
-
-
-   def create_plugin_method(name, &block)
-     self.class.send(:define_method, name, &block)
-   end
-
-   def register(name,plugin)
-     begin
-       require "jerakia/lookup/plugin/#{name}"
-     rescue LoadError => e
-       raise Jerakia::Error, "Cannot load plugin #{name}, #{e.message}"
-     end
-
-     
-     plugin.activate(name)
-     create_plugin_method(name) do
-       plugin
-     end
-     if plugin.respond_to?('autorun')
-       Jerakia.log.debug("Found autorun method for plugin #{name}, executing")
-
-       if plugin.method('autorun').arity == 1
-         plugin.autorun (@plugin_config[name.to_s] || {} )
-       else      
-         plugin.autorun
-       end
-     end
-   end
-
+  def initialize
+    Jerakia.log.debug('Loaded plugin handler')
+    @plugin_config = Jerakia.config[:plugins] || {}
+  end
+
+  def create_plugin_method(name, &block)
+    self.class.send(:define_method, name, &block)
+  end
+
+  def register(name, plugin)
+    begin
+      require "jerakia/lookup/plugin/#{name}"
+    rescue LoadError => e
+      raise Jerakia::Error, "Cannot load plugin #{name}, #{e.message}"
+    end
+
+    plugin.activate(name)
+    create_plugin_method(name) do
+      plugin
+    end
+    if plugin.respond_to?('autorun')
+      Jerakia.log.debug("Found autorun method for plugin #{name}, executing")
+
+      if plugin.method('autorun').arity == 1
+        plugin.autorun (@plugin_config[name.to_s] || {})
+      else
+        plugin.autorun
+      end
+    end
+  end
 end
-
-  

data/lib/jerakia/lookup.rb

@@ -3,6 +3,7 @@ class Jerakia::Lookup
   require 'jerakia/scope'
   require 'jerakia/lookup/plugin'
   require 'jerakia/lookup/pluginfactory'
+  require 'jerakia/lookup/plugin_config'
 
   attr_accessor :request
   attr_accessor :datasource
@@ -15,20 +16,18 @@ class Jerakia::Lookup
   attr_reader :pluginfactory
   attr_reader :datasource
 
-  def initialize(name,opts,req,scope)
-    
-    @name=name
-    @request=req
-    @valid=true
-    @scope_object=scope
-    @output_filters=[]
-    @proceed=true
+  def initialize(name, opts, req, scope)
+    @name = name
+    @request = req
+    @valid = true
+    @scope_object = scope
+    @output_filters = []
+    @proceed = true
     @pluginfactory = Jerakia::Lookup::PluginFactory.new
 
-
     # Validate options passed to the lookup
     #
-    valid_opts = [ :use ]
+    valid_opts = [:use]
 
     opts.keys.each do |opt_key|
       unless valid_opts.include?(opt_key)
@@ -36,17 +35,23 @@ class Jerakia::Lookup
       end
     end
 
-
     if opts[:use]
-       Array(opts[:use]).flatten.each do |plugin|
+      Array(opts[:use]).flatten.each do |plugin|
         plugin_load(plugin)
       end
     end
   end
- 
+
+  # Retrieve plugin specific configuration from the global configuration file
+  # gets passed to the plugin instance upon initilization.
+  #
+  def plugin_config(plugin)
+    Jerakia::Lookup::PluginConfig.new(plugin)
+  end
+
   def plugin_load(plugin)
     Jerakia.log.debug("Loading plugin #{plugin}")
-    pluginfactory.register(plugin, Jerakia::Lookup::Plugin.new(self))
+    pluginfactory.register(plugin, Jerakia::Lookup::Plugin.new(self, plugin_config(plugin)))
   end
 
   def plugin
@@ -57,7 +62,7 @@ class Jerakia::Lookup
     @datasource
   end
 
-  def datasource(source, opts={})
+  def datasource(source, opts = {})
     @datasource = Jerakia::Datasource.new(source, self, opts)
   end
 
@@ -69,11 +74,10 @@ class Jerakia::Lookup
     scope_object.value
   end
 
-
-  def output_filter(name,opts={})
+  def output_filter(name, opts = {})
     @output_filters << { :name => name, :opts => opts }
   end
-    
+
   def proceed?
     proceed
   end
@@ -109,38 +113,33 @@ class Jerakia::Lookup
     valid
   end
 
-
-  def get_matches(key,match)
-    matches = Array(match).select { |m| key[Regexp.new(m)] == key}
+  def get_matches(key, match)
+    matches = Array(match).select { |m| key[Regexp.new(m)] == key }
   end
-  
-  def confine(key=nil,match)
+
+  def confine(key = nil, match)
     if key
-      invalidate unless get_matches(key,match).size > 0
+      invalidate if get_matches(key, match).empty?
     else
       invalidate
     end
   end
 
-  def exclude(key=nil,match)
+  def exclude(key = nil, match)
     if key
-      invalidate if get_matches(key,match).size > 0
+      invalidate unless get_matches(key, match).empty?
     end
   end
-      
 
   def run
     Jerakia.log.verbose("lookup: #{@name} key: #{@request.key} namespace: #{@request.namespace.join('/')}")
     @datasource.run
-    response=@datasource.response
+    response = @datasource.response
     @output_filters.each do |filter|
       response.filter! filter[:name], filter[:opts]
     end
-    return response
+    response
   end
 
-
   private
-
 end
-

data/lib/jerakia/policy.rb

@@ -2,69 +2,84 @@ require 'jerakia/launcher'
 require 'jerakia/answer'
 require 'jerakia/schema'
 
-class Jerakia::Policy 
+class Jerakia
+  class Policy
+    attr_accessor :lookups
+    attr_reader   :answer
+    attr_reader   :scope
+    attr_reader   :lookup_proceed
+    attr_reader   :schema
+    attr_reader   :request
 
-  attr_accessor :lookups
-  attr_reader   :answer
-  attr_reader   :scope
-  attr_reader   :lookup_proceed
-  attr_reader   :schema
-  attr_reader   :request
-
-  def initialize(name, opts={}, req)
+    # _opts currently does not get used, but is included here as a placeholder
+    # for allowing policies to be declared with options;
+    # policy :foo, :option => :value do
+    #
+    def initialize(_name, _opts, req)
+      if req.use_schema && Jerakia.config[:enable_schema]
+        schema_config = Jerakia.config[:schema] || {}
+        @schema = Jerakia::Schema.new(req, schema_config)
+      end
 
-    if req.use_schema and Jerakia.config[:enable_schema]
-      schema_config = Jerakia.config[:schema] || {}
-      @schema = Jerakia::Schema.new(req, schema_config)
+      @lookups = []
+      @request = req
+      @answer = Jerakia::Answer.new(req.lookup_type)
+      @scope = Jerakia::Scope.new(req)
+      @lookup_proceed = true
     end
 
+    def clone_request
+      Marshal.load(Marshal.dump(request))
+    end
 
-    @lookups=[]
-    @request=req
-    @answer=Jerakia::Answer.new(req.lookup_type)
-    @scope=Jerakia::Scope.new(req)
-    @lookup_proceed = true    
-  end
-
-  def clone_request
-    Marshal.load(Marshal.dump(request))
-  end
+    def submit_lookup(lookup)
+      raise Jerakia::PolicyError, "Lookup #{lookup.name} has no datasource defined" unless lookup.get_datasource
+      @lookups << lookup if lookup.valid? && @lookup_proceed
+      @lookup_proceed = false if !lookup.proceed? && lookup.valid?
+    end
 
-  def submit_lookup(lookup)
-    raise Jerakia::PolicyError, "Lookup #{lookup.name} has no datasource defined" unless lookup.get_datasource
-    @lookups << lookup if lookup.valid? and @lookup_proceed
-    @lookup_proceed = false if !lookup.proceed? and lookup.valid?
-  end
+    def execute
+      response_entries = []
 
-  def fire!
-    response_entries = []
+      @lookups.each do |l|
+        responses = l.run
+        lookup_answers = responses.entries.map { |r| r }
+        response_entries << lookup_answers if lookup_answers
+      end
 
-    @lookups.each do |l|
-      responses = l.run
-      lookup_answers = responses.entries.map { |r| r }
-      response_entries << lookup_answers if lookup_answers
+      response_entries.flatten.each { |res| process_response(res) }
+      consolidate_answer
     end
 
+    private
 
-    response_entries.flatten.each do |res|
+    # Process the response depending on the requests lookup_type
+    # if it is a :first lookup then we only want to set the result
+    # once, if it's cascading, we should ammend the payload array
+    #
+    def process_response(res)
       case request.lookup_type
       when :first
-          @answer.payload ||= res[:value]
-          @answer.datatype ||= res[:datatype]
+        @answer.payload ||= res[:value]
+        @answer.datatype ||= res[:datatype]
       when :cascade
-          @answer.payload << res[:value]
+        @answer.payload << res[:value]
       end
     end
 
-    if request.lookup_type == :cascade && @answer.payload.is_a?(Array)
-      case request.merge
-      when :array
-        @answer.flatten_payload!
-      when :hash,:deep_hash
-        @answer.merge_payload!(request.merge)
+    # Once all the responses are submitted into the answers payload
+    # we need to consolidate the data based on the merge behaviour
+    # requested.
+    #
+    def consolidate_answer
+      if request.lookup_type == :cascade && @answer.payload.is_a?(Array)
+        case request.merge
+        when :array
+          @answer.flatten_payload!
+        when :hash, :deep_hash
+          @answer.merge_payload!(request.merge)
+        end
       end
     end
-
   end
 end
-

data/lib/jerakia/request.rb

@@ -1,6 +1,7 @@
+require 'jerakia'
+require 'jerakia/log'
 class Jerakia
   class Request
-
     attr_accessor :key
     attr_accessor :namespace
     attr_accessor :merge
@@ -11,7 +12,7 @@ class Jerakia
     attr_accessor :scope_options
     attr_accessor :use_schema
 
-    def initialize(opts={})
+    def initialize(opts = {})
       options        = defaults.merge(opts)
       @key           = options[:key]
       @namespace     = options[:namespace]

data/lib/jerakia/response/filter/encryption.rb

@@ -17,30 +17,27 @@ require 'yaml'
 class Jerakia::Response
   module Filter
     module Encryption
-
-      def filter_encryption(opts={})
+      def filter_encryption(_opts = {})
         parse_values do |val|
-          if val.is_a?(String)
-            decrypt val
-          end
+          decrypt val if val.is_a?(String)
           val
         end
       end
 
       def decrypt(data)
         if encrypted?(data)
-          public_key = config["eyaml"]["public_key"]
-          private_key = config["eyaml"]["private_key"]
+          public_key = config['eyaml']['public_key']
+          private_key = config['eyaml']['private_key']
           Hiera::Backend::Eyaml::Options[:pkcs7_private_key] = private_key
           Hiera::Backend::Eyaml::Options[:pkcs7_public_key] = public_key
           parser = Hiera::Backend::Eyaml::Parser::ParserFactory.hiera_backend_parser
-          
+
           tokens = parser.parse(data)
-          decrypted = tokens.map{ |token| token.to_plain_text }
+          decrypted = tokens.map(&:to_plain_text)
           plaintext = decrypted.join
           Jerakia.log.debug(plaintext)
           plaintext.chomp!
-          data.clear.insert(0,plaintext)
+          data.clear.insert(0, plaintext)
         else
           data
         end
@@ -52,5 +49,3 @@ class Jerakia::Response
     end
   end
 end
-
-

data/lib/jerakia/response/filter/strsub.rb

@@ -1,6 +1,6 @@
 # strsub is in output filter that matches tags in data and replaces them
 # for values in the scope.  It mimics the hiera features of being able to
-# embed %{::var} in YAML documents.  This output filter may not provide 
+# embed %{::var} in YAML documents.  This output filter may not provide
 # 100% compatibility to hiera but it should cover most scenarios.
 #
 # Jerakia does not support method or literal interpolations, just straightforward %{var} and %{::var}
@@ -10,12 +10,9 @@
 class Jerakia::Response
   module Filter
     module Strsub
-
-      def filter_strsub(opts={})
+      def filter_strsub(_opts = {})
         parse_values do |val|
-          if val.is_a?(String)
-            do_substr(val)
-          end
+          do_substr(val) if val.is_a?(String)
           val
         end
       end
@@ -24,12 +21,10 @@ class Jerakia::Response
         data.gsub!(/%\{([^\}]*)\}/) do |tag|
           Jerakia.log.debug("matched substr #{tag}")
           scopekey = tag.match(/\{([^\}]+)\}/)[1]
-          scopekey.gsub!(/^::/,'')
+          scopekey.gsub!(/^::/, '')
           lookup.scope[scopekey.to_sym]
         end
       end
     end
   end
 end
-
-

data/lib/jerakia/response/filter.rb

@@ -1,9 +1,9 @@
 class Jerakia::Response
   module Filter
-      def filter!(name,opts)
-        Jerakia::Util.autoload('response/filter', name)
-        instance_eval "extend Jerakia::Response::Filter::#{name.to_s.capitalize}"
-        instance_eval "self.filter_#{name.to_s} (#{opts})"
-      end
+    def filter!(name, opts)
+      Jerakia::Util.autoload('response/filter', name)
+      instance_eval "extend Jerakia::Response::Filter::#{name.to_s.capitalize}"
+      instance_eval "self.filter_#{name} (#{opts})"
+    end
   end
 end

data/lib/jerakia/response.rb

@@ -1,17 +1,16 @@
 class Jerakia::Response < Jerakia
-
   attr_accessor :entries
   attr_reader :lookup
 
   def initialize(lookup)
-    @entries=[]
-    @lookup=lookup
+    @entries = []
+    @lookup = lookup
     require 'jerakia/response/filter'
     extend Jerakia::Response::Filter
   end
 
   def want?
-    if lookup.request.lookup_type == :first && entries.length > 0
+    if lookup.request.lookup_type == :first && !entries.empty?
       return false
     else
       return true
@@ -20,14 +19,14 @@ class Jerakia::Response < Jerakia
 
   def submit(val)
     Jerakia.log.debug "Backend submitted #{val}"
-    unless want?
-      no_more_answers
-    else
+    if want?
       @entries << {
         :value => val,
         :datatype => val.class.to_s.downcase
       }
       Jerakia.log.debug "Added answer #{val}"
+    else
+      no_more_answers
     end
   end
 
@@ -44,14 +43,9 @@ class Jerakia::Response < Jerakia
       end
       entry
     end
-
   end
-      
-
 
   def no_more_answers
-    Jerakia.log.debug "warning: backend tried to submit too many answers"
+    Jerakia.log.debug 'warning: backend tried to submit too many answers'
   end
-
 end
-