jerakia 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea3f9b99ad3814fc4868f19d64d8f47adf16e940
-  data.tar.gz: 0ff66c99cdff190f8047dfce865cc01e749efa19
+  metadata.gz: 6e4145ea38aa8d6573c8511c06241c79032e38a1
+  data.tar.gz: d42e6335997192ff954540abf9e9930f35701217
 SHA512:
-  metadata.gz: 1e291ef9b8af754741a04088d6782d1710d2194da4aedc73ddd6a447078e06ad119afca6c338080683300aa2e89be8adea381dba91468790acbcb5ccc97977d9
-  data.tar.gz: 1ffc73296862825e61e8e6eb5ec6c46d6b31b27ce9d47150783879bf4e15762692b9b42fbff07401dd4e15c87aefbb5d84c8c3e53a7bf997ad29af01292e41ff
+  metadata.gz: 7ae5b4c70dc8e34e1e486b89f297cae5772bfb138cfa057fbf040b393c00ba0dc65141f00b10e7c136fa6b0c3e2ad89b12dc47ecca0b8c9dd01cc6c6910c9fdd
+  data.tar.gz: 52cfaffb30597c12f0d4c881bd795239893ff6c1d49ec8ddb5aca03db9d8316404977e8eeb8ff28894f8ccdb69cbd7406350fca126c3b8433e85ade3ac873b10

data/lib/jerakia/answer.rb

@@ -10,6 +10,7 @@ class Jerakia
     def initialize(lookup_type = :first, merge_strategy = :array)
       @lookup_type = lookup_type
       @merge_strategy = merge_strategy
+      @found = false
       case lookup_type
       when :first
         @payload = nil
@@ -20,20 +21,29 @@ class Jerakia
     end
 
     def process_response(response_entries)
-      response_entries.flatten.each do |res|
+      responses = response_entries.flatten.compact
+
+      return nil if responses.empty?
+      @found = true
+
+      responses.each do |res|
         case lookup_type
         when :first
-          @payload = res[:value]
-          @datatype = res[:datatype]
+          @payload = res.value
+          @datatype = res.datatype
           Jerakia.log.debug("Registered answer as #{payload}")
           break
         when :cascade
-          @payload << res[:value]
+          @payload << res.value
         end
       end
       consolidate
     end
 
+    def found?
+      @found
+    end
+
     def consolidate
       if lookup_type == :cascade && payload.is_a?(Array)
         case merge_strategy

data/lib/jerakia/datasource.rb

@@ -15,9 +15,8 @@ class Jerakia
       attr_reader :response
 
       def initialize(lookup, opts)
-        self.class.validate_options(opts)
         @response = Jerakia::Response.new(lookup)
-        @options = opts
+        @options = self.class.set_options(opts)
         @request = lookup.request 
         @features = []
       end
@@ -64,11 +63,17 @@ class Jerakia
           opt
         end
       end
-      def self.validate_options(args)
+
+      def self.set_options(args)
+        opts = {}
         options.keys.each do |k|
-          options[k].call(args[k])
+          opts[k] = options[k].call(args[k])
         end
+        validate_options(args)
+        opts
+      end
 
+      def self.validate_options(args)
         args.keys.each do |k|
           raise Jerakia::DatasourceArgumentError, "Unknown option #{k}" unless options.keys.include?(k)
         end

data/lib/jerakia/datasource/consul_kv.rb

@@ -0,0 +1,88 @@
+require 'diplomat'
+require 'uri'
+
+class Jerakia::Datasource::Consul_kv < Jerakia::Datasource::Instance
+
+  # datacenter option sets the :dc method in the Diplomat
+  # request to perform a consul lookup using a particular
+  # datacenter
+  #
+  option(:datacenter) { |str| str.is_a?(String) }
+  
+  # to_hash, when used with recursive, will consolidate the
+  # results into a hash, instead of an array
+  #
+  option(:to_hash, :default => true) { |opt| 
+    [ TrueClass, FalseClass ].include?(opt.class)
+  }
+
+  # Recursive will return the entire data structure from console
+  # rather than just the requested key
+  #
+  option(:recursive, :default => false) { |opt|
+    [ TrueClass, FalseClass ].include?(opt.class)
+  }
+
+  # The searchpath is the root path of the request, which will
+  # get appended with the namespace, and key if applicable.
+  # We allow this option to be ommited in case the lookup path
+  # starts at the namesapce.
+  #
+  option(:searchpath, :default => ['']) { |opt| opt.is_a?(Array) }
+
+  # Set any consul parameters against the Diplomat class
+  #
+  # These values are set in jerakia.yaml and are loaded directly
+  # to the class when we load the datasource for the first time.
+  #
+  consul_config = Jerakia.config['consul']
+  if consul_config.is_a?(Hash)
+    Diplomat.configure do |config|
+      config.url = consul_config['url'] if consul_config.has_key?('url')
+      config.acl_token = consul_config['acl_token'] if consul_config.has_key?('acl_token')
+      config.options = consul_config['options'] if consul_config['options'].is_a?(Hash)
+    end
+  end
+
+
+
+  # Entrypoint for Jerakia lookups starts here.
+  #
+  def lookup
+    
+    Jerakia.log.debug("[datasource::console_kv] backend performing lookup for #{request.key}")
+    paths = options[:searchpath].reject { |p| p.nil? }
+
+    key = request.key
+    namespace = request.namespace
+
+
+    answer do |response|
+
+      break if paths.empty?
+      path = paths.shift.split('/').compact
+
+
+      path << namespace
+      path << key unless key.nil?
+
+      diplomat_options = {
+        :recurse => options[:recursive],
+        :convert_to_hash => options[:to_hash],
+        :dc => options[:datacenter],
+      }
+
+      begin
+       key_path = path.flatten.join('/')
+       Jerakia.log.debug("[datasource::consul_kv] Looking up #{key_path} with options #{diplomat_options}")
+       result = Diplomat::Kv.get(key_path, diplomat_options)
+      rescue Diplomat::KeyNotFound => e
+        Jerakia.log.debug("NotFound encountered, skipping to next path entry")
+        next
+      rescue Faraday::ConnectionFailed => e
+        raise Jerakia::Error, "Failed to connect to consul service: #{e.message}"
+      end
+      response.submit result
+    end
+  end
+end

data/lib/jerakia/datasource/file.rb

@@ -8,7 +8,7 @@ class Jerakia::Datasource::File < Jerakia::Datasource::Instance
 
   option :format,  :default => :yaml
   option :docroot, :default => '/var/lib/jerakia/data'
-  option :extention
+  option :extension
   option :enable_caching, :default => true
 
   def load_format_handler
@@ -88,7 +88,7 @@ class Jerakia::Datasource::File < Jerakia::Datasource::Instance
       path = paths.shift
       break unless path
       data = read_from_file(path)
-      unless data[request.key].nil?
+      if data.has_key?(request.key)
         response.submit data[request.key]
       end
     end

data/lib/jerakia/datasource/http.rb

@@ -19,6 +19,14 @@ class Jerakia::Datasource::Http < Jerakia::Datasource::Instance
   option :http_connect_timeout, :type => Integer
   option :paths, :type => Array, :required => true
 
+  # When lookup_key is set to false, the datasource will not attempt to
+  # look up the key from a hash that gets returned.  This flag will be
+  # set to default of false in Jerakia 3.0
+  #
+  option(:lookup_key, :default => true) { |opt|
+    [TrueClass,FalseClass].include?(opt.class)
+  }
+
   def lookup
 
     lookup_supported_params = [
@@ -53,9 +61,10 @@ class Jerakia::Datasource::Http < Jerakia::Datasource::Instance
       Jerakia.log.debug("Datasource provided #{data} (#{data.class}) looking for key #{request.key}")
 
       if data.is_a?(Hash)
-        unless data[request.key].nil?
-          Jerakia.log.debug("Found data #{data[request.key]}")
-          response.submit data[request.key]
+        if options[:lookup_key]
+          response.submit data[request.key] if data.has_key?(request.key)
+        else
+          response.submit data
         end
       else
         unless options[:output] == 'plain' || options[:failure] == 'graceful'

data/lib/jerakia/dsl/lookup.rb

@@ -21,8 +21,6 @@ class Jerakia
       # @api: public
       def datasource(name, opts = {})
         lookup.datasource = { :name => name, :opts => opts }
-        #datasource = Jerakia::Datasource.new(name, lookup, opts)
-        #lookup.datasource = datasource
       end
 
       # pass through exposed functions from the main lookup object

data/lib/jerakia/policy.rb

@@ -44,6 +44,7 @@ class Jerakia
         break unless lookup_instance.proceed?
       end
       answer.process_response(response_entries)
+      Jerakia.log.debug(answer)
       return answer
     end
 

data/lib/jerakia/response.rb

@@ -1,7 +1,30 @@
 class Jerakia::Response < Jerakia
-  attr_accessor :entries
   attr_reader :lookup
 
+  class Entry
+    attr_reader :value
+    attr_reader :datatype
+    attr_reader :valid
+
+    def initialize(val)
+      @valid = true
+      set_value(val)
+    end
+
+    def invalidate
+      @valid = false
+    end
+
+    def valid?
+      @valid
+    end
+
+    def set_value(val)
+      @value = val
+      @datatype = val.class.to_s.downcase
+    end
+  end
+
   def initialize(lookup)
     @entries = []
     @lookup = lookup
@@ -17,28 +40,30 @@ class Jerakia::Response < Jerakia
     end
   end
 
+
   def submit(val)
     Jerakia.log.debug "Backend submitted #{val}"
     if want?
-      @entries << {
-        :value => val,
-        :datatype => val.class.to_s.downcase
-      }
+      @entries << Jerakia::Response::Entry.new(val)
       Jerakia.log.debug "Added answer #{val}"
     else
       no_more_answers
     end
   end
 
-  def values
-    Jerakia::Util.walk(@entries) do |entry|
+  def responses
+    @entries.each do |entry|
       yield entry
     end
   end
 
+  def entries
+    @entries.select { |e| e.valid? }
+  end
+
   def parse_values
     @entries.map! do |entry|
-      Jerakia::Util.walk(entry[:value]) do |v|
+      Jerakia::Util.walk(entry.value) do |v|
         yield v
       end
       entry

data/lib/jerakia/response/entry.rb

@@ -0,0 +1,17 @@
+#class Jerakia::Response
+#    class Entry
+#
+#      attr_reader :value
+#      attr_reader :datatype
+#
+#      def initialize(val)
+#        set_value(val)
+#      end
+#
+#      def set_value(val)
+#        @value = val
+#        @datatype = val.class.to_s.downcase
+#      end
+#    end
+#end
+#

data/lib/jerakia/response/filter.rb

@@ -1,10 +1,14 @@
 class Jerakia::Response
   module Filter
     def filter!(name, opts = {})
+
+      unless opts.is_a?(Hash) || opts.is_a?(Array)
+        raise Jerakia::PolicyError, "Output filters may only accept hashes or arrays as arguments"
+      end
       Jerakia::Util.autoload('response/filter', name)
       Jerakia.log.debug("Invoking output filter #{name}")
       instance_eval "extend Jerakia::Response::Filter::#{name.to_s.capitalize}"
-      instance_eval "self.filter_#{name} (#{opts})"
+      instance_eval "self.filter_#{name}(#{opts})"
     end
   end
 end

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

@@ -0,0 +1,25 @@
+class Jerakia::Response
+  module Filter
+    module Dig
+      def filter_dig(path = [])
+        raise Jerakia::PolicyError, "Argument to output filter dig must be an array" unless path.is_a?(Array)
+        Jerakia.log.debug("[output_filter:dig]: Attempting to dig using path #{path}")
+        responses do |entry|
+
+          unless entry.value.is_a?(Hash)
+            raise Jerakia::Error, "Cannot perform dig on a non hash value"
+          end
+
+          value = Jerakia::Util.dig(entry.value, path.flatten)
+          if value == :not_found
+            Jerakia.log.debug('[output_filter:dig]: Digging value from response failed, invalidating')
+            entry.invalidate
+          else
+            entry.set_value(value)
+            Jerakia.log.debug("[output_filter:dig]: Re-submitting response as #{value}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jerakia/server/rest.rb

@@ -123,7 +123,8 @@ class Jerakia
         rescue Jerakia::Error => e
           request_failed(e.message, 501)
         end
-        encode_result({ :status => 'ok', 
+        encode_result({ :status => 'ok',
+                        :found => answer.found?,
                         :payload => answer.payload})
       end
 

data/lib/jerakia/util.rb

@@ -6,6 +6,20 @@ class Jerakia
         require "jerakia/#{path}/#{mod}"
       end
 
+      def dig(data, dig_path)
+        key = dig_path.shift
+        if dig_path.empty?
+          if data.has_key?(key)
+            return data[key]
+          else
+            return :not_found
+          end
+        else
+          return :not_found unless data[key].is_a?(Hash)
+          return dig(data[key], dig_path)
+        end
+      end
+
       def walk(data)
         if data.is_a?(Hash)
           walk_hash(data) do |target|

data/lib/jerakia/version.rb

@@ -3,5 +3,5 @@ class Jerakia
   #
   # This should be updated when a new gem is released and it is read from the gemspec file
   #
-  VERSION = '2.4.0'.freeze
+  VERSION = '2.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jerakia
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Craig Dunn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-14 00:00:00.000000000 Z
+date: 2018-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: diplomat
+  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'
 description: Extendable and flexible data lookup system
 email: 
 executables:
@@ -143,6 +157,7 @@ files:
 - lib/jerakia/cli/token.rb
 - lib/jerakia/config.rb
 - lib/jerakia/datasource.rb
+- lib/jerakia/datasource/consul_kv.rb
 - lib/jerakia/datasource/dummy.rb
 - lib/jerakia/datasource/file.rb
 - lib/jerakia/datasource/file/json.rb
@@ -163,7 +178,9 @@ files:
 - lib/jerakia/policy.rb
 - lib/jerakia/request.rb
 - lib/jerakia/response.rb
+- lib/jerakia/response/entry.rb
 - lib/jerakia/response/filter.rb
+- lib/jerakia/response/filter/dig.rb
 - lib/jerakia/response/filter/encryption.rb
 - lib/jerakia/response/filter/strsub.rb
 - lib/jerakia/schema.rb