jerakia 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4dda5d22fe6e0fa29b9ce287a9b44f20c2fe3e9
-  data.tar.gz: 21e5f066edc6cd60249767e8ccd277559d9419d6
+  metadata.gz: 4303c4efbf02503a4942b9db6c1396a3f3076a39
+  data.tar.gz: 198c1a968a1502b73ce15c0467225e001dff93f8
 SHA512:
-  metadata.gz: ab871bf140fd08288bbf39a7be8101c7151823c8eb3249e47e7ed89468399e500111edfc2dc5e108fdae7a557213811afedc5f3e8fb39c310fd27e68c718d187
-  data.tar.gz: 2d793c5c420b128380d813c92e99bb7c56ff137003a016b2f624eb54e9c2a225172f7a7ae49c40495bbbf98a8342a723347bb3deba7699aaab036268d35b511b
+  metadata.gz: d8ab25c31d6044d86ba469d5f33c043152e269a4a22f52f991b3edfe8950012e0ec3889cf77c80e8ce4047af154176a438914d4f3bdcd7e72a86b9ab730cc826
+  data.tar.gz: ab5dd6838aec464f3a053d227ee71ed3180cbd79d0c592ba4b490023501882e8467b94b302f6c2176e2e4c052ced0fa1685ac602bf6c56c0719c848c34c512be

data/lib/jerakia.rb

@@ -15,6 +15,7 @@ class Jerakia
   require 'jerakia/error'
 
   attr_reader :options
+  attr_reader :launcher
 
   class << self
     attr_reader :config
@@ -26,6 +27,7 @@ class Jerakia
 
   def initialize(options = {})
     @options = options
+    @policies = {}
 
     load_config
     load_log_handler
@@ -36,14 +38,11 @@ class Jerakia
 
     log.debug('Jerakia initialized')
     Jerakia.log.verbose("Jerakia started. Version #{Jerakia::VERSION}")
+    @launcher = Jerakia::Launcher.new
   end
 
   def lookup(request)
-    lookup_instance = Jerakia::Launcher.new(request)
-    lookup_instance.invoke_from_file
-    lookup_instance.answer
-  rescue Jerakia::Error => e
-    Jerakia.fatal(e.message, e)
+    launcher.policies[request.policy.to_sym].run(request)
   end
 
   def self.fatal(msg, e)

data/lib/jerakia/answer.rb

@@ -4,9 +4,12 @@ class Jerakia
 
     attr_accessor :payload
     attr_accessor :datatype
+    attr_reader :merge_strategy
     attr_reader :lookup_type
 
-    def initialize(lookup_type = :first)
+    def initialize(lookup_type = :first, merge_strategy = :array)
+      @lookup_type = lookup_type
+      @merge_strategy = merge_strategy
       case lookup_type
       when :first
         @payload = nil
@@ -16,17 +19,44 @@ class Jerakia
       end
     end
 
+    def process_response(response_entries)
+      response_entries.flatten.each do |res|
+        case lookup_type
+        when :first
+          @payload = res[:value]
+          @datatype = res[:datatype]
+          Jerakia.log.debug("Registered answer as #{payload}")
+          break
+        when :cascade
+          @payload << res[:value]
+        end
+      end
+      consolidate
+    end
+
+    def consolidate
+      if lookup_type == :cascade && payload.is_a?(Array)
+        case merge_strategy
+        when :array
+          flatten_payload!
+        when :hash, :deep_hash
+          merge_payload!
+        end
+      end
+    end
+
+
     def flatten_payload!
       @payload.flatten!
     end
 
     # TODO: consolidate this into less lines
     #
-    def merge_payload!(method = :hash) # rubocop:disable Metrics/MethodLength
+    def merge_payload! # rubocop:disable Metrics/MethodLength
       payload_hash = {}
       @payload.each do |p|
         next unless p.is_a?(Hash)
-        case method
+        case merge_strategy
         when :hash
           payload_hash = p.merge(payload_hash)
         when :deep_hash

data/lib/jerakia/cli.rb

@@ -5,13 +5,15 @@ require 'yaml'
 require 'jerakia/cli/server'
 require 'jerakia/cli/token'
 require 'jerakia/cli/lookup'
-
+require 'jerakia/cli/secret'
 
 class Jerakia
   class CLI < Thor
     include Jerakia::CLI::Server
     include Jerakia::CLI::Lookup
     include Jerakia::CLI::Token
+    include Jerakia::CLI::Secret
+
 
     desc 'version', 'Version information'
     def version

data/lib/jerakia/cli/lookup.rb

@@ -66,13 +66,13 @@ class Jerakia
                  efault: 'json',
                  desc: 'Output format, yaml or json'
 
-          def lookup(key)
+          def lookup(key=nil)
             # Thor by default now returns a frozen options hash so we
             # need to dup this here to prevent problems later with
             # modifying the request object
             #
             options_copy = options.dup
-
+            key_copy = key.nil? ? key : key.dup
             case true
             when options[:verbose]
               loglevel = 'verbose'
@@ -91,7 +91,7 @@ class Jerakia
                                 :loglevel => loglevel,
                                 :trace    => options[:trace])
               req = Jerakia::Request.new(
-                :key           => key.dup,
+                :key           => key_copy,
                 :namespace     => options_copy[:namespace].split(/::/),
                 :policy        => options_copy[:policy].to_sym,
                 :lookup_type   => options_copy[:type].to_sym,

data/lib/jerakia/cli/secret.rb

@@ -0,0 +1,58 @@
+require 'jerakia/encryption'
+require 'jerakia'
+
+class Jerakia
+  class CLI < Thor
+    module Secret
+      class Secret < Thor
+        
+        Jerakia.new
+        @provider = Jerakia::Encryption.new
+
+        class << self
+          attr_reader :provider
+        end
+
+        no_commands do
+          def provider
+            self.class.provider
+          end
+        end
+
+        if @provider.features?(:decrypt)
+          desc 'decrypt <encrypted value>', 'Decrypt an encrypted value'
+          def decrypt(encrypted)
+            begin
+              plaintext = provider.decrypt(encrypted)
+            rescue Jerakia::EncryptionError => e
+              puts e.message
+              exit(1)
+            end
+            puts plaintext
+          end
+        end
+
+        if @provider.features?(:encrypt)
+          desc 'encrypt <string>', 'Encrypt a plain text string'
+          def encrypt(plaintext)
+            begin
+              encrypted = provider.encrypt(plaintext)
+            rescue Jerakia::EncryptionError => e
+              puts e.message
+              exit(1)
+            end
+            puts encrypted
+          end
+        end
+      end
+
+      def self.included(thor)
+        thor.class_eval do
+          info = Secret.provider.loaded? ? "" : "(No encryption provider configured!)"
+          desc 'secret [SUBCOMMAND] <options>', "Manage encrypted secrets #{info}"
+          subcommand 'secret', Secret
+        end
+      end
+    end
+  end
+end

data/lib/jerakia/datasource.rb

@@ -3,47 +3,88 @@
 require 'jerakia/cache'
 class Jerakia
   class Datasource
-    require 'jerakia/response'
+    class Instance
 
-    attr_reader :response
-    attr_reader :options
-    attr_reader :lookup
-    attr_reader :name
-
-    def initialize(name, lookup, opts)
-      @response = Jerakia::Response.new(lookup)
-      @options = opts
-      @lookup = lookup
-      @name = name
-      begin
-        require "jerakia/datasource/#{name}"
-        eval "extend Jerakia::Datasource::#{name.capitalize}"
-      rescue LoadError => e
-        raise Jerakia::Error, "Cannot load datasource #{name} in lookup #{lookup.name}, #{e.message}"
+      class << self
+        attr_reader :features
+        attr_accessor :options
       end
-    end
 
-    ## used for verbose logging
-    def whoami
-      "datasource=#{@name}  lookup=#{@lookup.name}"
-    end
+      attr_reader :options
+      attr_reader :request
+      attr_reader :response
 
-    def option(opt, data = {})
-      if @options[opt].nil? && data.key?(:default)
-        @options[opt] = data[:default]
+      def initialize(lookup, opts)
+        self.class.validate_options(opts)
+        @response = Jerakia::Response.new(lookup)
+        @options = opts
+        @request = lookup.request 
+        @features = []
+      end
+
+      def answer(data=nil)
+        if block_given?
+          while @response.want?
+            yield @response
+          end
+        else
+          @response.submit(data) if response.want? and not data.nil?
+        end
       end
 
-      Jerakia.log.debug("[#{whoami}]: options[#{opt}] to #{options[opt]} [#{options[opt].class}]")
-      if @options[opt].nil?
-        raise Jerakia::PolicyError, "#{opt} option must be supplied for datasource #{@name} in lookup #{lookup.name}" if data[:mandatory]
-      else
-        if data[:type]
-          if Array(data[:type]).select { |t| @options[opt].is_a?(t) }.empty?
-            raise Jerakia::PolicyError,
-                  "#{opt} is a #{@options[opt].class} but must be a #{data[:type]}  for datasource #{@name} in lookup #{lookup.name}"
+      def self.feature(name)
+        @features << name.to_sym unless @features.include?(name.to_sym)
+      end
+
+      def features?(name)
+        @features.include?(name)
+      end
+
+      def self.option(name, arguments = {}, &block)
+        self.options={} if self.options.nil?
+        @options[name] = Proc.new do |opt|
+          if arguments[:default]
+            opt = arguments[:default] if opt.nil?
+          end
+          if arguments[:required]
+            raise Jerakia::DatasourceArgumentError, "Must specify #{name} parameter" if opt.nil?
+          end
+
+          if block_given?
+            unless opt.nil?
+              raise Jerakia::DatasourceArgumentError, "Validation failed for #{name}" unless yield opt
+            end
           end
+          opt
         end
       end
+      def self.validate_options(args)
+        options.keys.each do |k|
+          options[k].call(args[k])
+        end
+
+        args.keys.each do |k|
+          raise Jerakia::DatasourceArgumentError, "Unknown option #{k}" unless options.keys.include?(k)
+        end
+      end
+    end
+
+    require 'jerakia/response'
+
+    def self.load_datasource(name)
+      require "jerakia/datasource/#{name.to_s}"
+    end
+
+    def self.class_of(name)
+      return eval "Jerakia::Datasource::#{name.to_s.capitalize}"
+    end
+      
+
+    def self.run(lookup)
+      options  = lookup.datasource[:opts]
+      datasource = class_of(lookup.datasource[:name]).new(lookup, options)
+      datasource.lookup
+      return datasource.response
     end
   end
 end

data/lib/jerakia/datasource/dummy.rb

@@ -1,12 +1,8 @@
-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, Hash, Array], :default => 'Returned data'
-      response.submit options[:return]
-    end
+class Jerakia::Datasource::Dummy < Jerakia::Datasource::Instance
+  option :return, :default => 'Returned data'
+  def lookup
+    answer options[:return]
   end
 end
+
+

data/lib/jerakia/datasource/file.rb

@@ -1,81 +1,95 @@
 require 'jerakia/cache/file'
 
-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}"
-      @file_format = eval "Jerakia::Datasource::File::#{class_name}"
-    end
+#Jerakia::Datasource.define(:file) do
+#
+class Jerakia::Datasource::File < Jerakia::Datasource::Instance
 
-    def cache
-      Jerakia::Cache::File
-    end
+  option(:searchpath, :required => true) { |opt| opt.is_a?(Array) }
 
-    def get_file_with_cache(diskname)
-      if options[:enable_caching]
-        Jerakia.log.debug("Querying cache for file #{diskname}")
-        cache.retrieve(diskname)
-      else
-        ::File.read(diskname) if ::File.exists?(diskname)
-      end
-    end
+  option :format,  :default => :yaml
+  option :docroot, :default => '/var/lib/jerakia/data'
+  option :extention
+  option :enable_caching, :default => true
 
-    def list_fragments(prefix, extension)
-      Dir["#{prefix}.d/*.#{extension}"] if ::File.directory?("#{prefix}.d")
-    end
+  def load_format_handler
+    format = options[:format]
+    require "jerakia/datasource/file/#{format.to_s}"
+    eval "extend Jerakia::Datasource::File::#{format.to_s.capitalize}"
+  end
 
-    def read_from_file(fname)
-      fpath = []
-      fpath << options[:docroot] unless fname[0] == '/'
-      fpath << [fname, lookup.request.namespace]
+  def format_handler
+    format = options[:format]
+    eval "Jerakia::Datasource::File::#{format.to_s.capitalize}"
+  end
+
+  def extension
+    options[:extension] || format_handler::EXTENSION
+  end
 
-      extension = options[:extension] || @file_format::EXTENSION
-      diskname_prefix = ::File.join(fpath.flatten).gsub(/\/$/, '').to_s
-      diskname = "#{diskname_prefix}.#{extension}"
+  def cache
+    Jerakia::Cache::File
+  end
 
-      files = [diskname]
-      files << list_fragments(diskname_prefix, extension)
+  def get_file_with_cache(diskname)
+    Jerakia.log.debug("Querying cache for file #{diskname}")
+    cache.retrieve(diskname)
+  end
 
-      raw_data = ''
+  def get_file(diskname)
+    ::File.read(diskname) if ::File.exists?(diskname)
+  end
 
-      files.flatten.compact.each do |f|
-        Jerakia.log.debug("read_from_file()  #{f}")
+  def list_fragments(prefix, extension)
+    Dir["#{prefix}.d/*.#{extension}"] if ::File.directory?("#{prefix}.d")
+  end
+
+  def read_from_file(fname)
+    docroot = options[:docroot]
+    namespace = request.namespace
+    cached = options[:enable_caching]
+    
+    fpath = []
+    fpath << docroot unless fname[0] == '/'
+    fpath << [fname, namespace]
+
+    diskname_prefix = ::File.join(fpath.flatten).gsub(/\/$/, '').to_s
+    diskname = "#{diskname_prefix}.#{extension}"
+
+    files = [diskname]
+    files << list_fragments(diskname_prefix, extension)
+
+    raw_data = ''
+
+    files.flatten.compact.each do |f|
+      Jerakia.log.debug("read_from_file()  #{f}")
+      file_contents = get_file_with_cache(f)
+      if cached
         file_contents = get_file_with_cache(f)
-        raw_data << file_contents if file_contents
+      else
+        file_content = get_file(f)
       end
+      raw_data << file_contents if file_contents
+    end
 
-      begin
-        file_format.convert(raw_data)
-      rescue Jerakia::FileParseError => e
-        raise Jerakia::FileParseError, "While parsing #{diskname}: #{e.message}"
-      end
+    begin
+      convert(raw_data)
+    rescue Jerakia::FileParseError => e
+      raise Jerakia::FileParseError, "While parsing #{diskname}: #{e.message}"
     end
+  end
+
+  def lookup
+    Jerakia.log.debug("Searching key #{request.key} from file format #{options[:format]}")
+
+    load_format_handler
+    paths=options[:searchpath].flatten
 
-    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].flatten.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}")
-        unless data[lookup.request.key].nil?
-          Jerakia.log.debug("Found data #{data[lookup.request.key]}")
-          response.submit data[lookup.request.key]
-        end
+    answer do |response|
+      path = paths.shift
+      break unless path
+      data = read_from_file(path)
+      unless data[request.key].nil?
+        response.submit data[request.key]
       end
     end
   end