jerakia 1.1.2 → 1.2.0

data/lib/jerakia/cli.rb

@@ -2,126 +2,16 @@ require 'thor'
 require 'jerakia'
 require 'json'
 require 'yaml'
+require 'jerakia/cli/server'
+require 'jerakia/cli/token'
+require 'jerakia/cli/lookup'
+
 
 class Jerakia
   class CLI < Thor
-    desc 'lookup [KEY]', 'Lookup [KEY] with Jerakia'
-    option :config,
-           aliases: :c,
-           type: :string,
-           desc: 'Configuration file'
-    option :policy,
-           aliases: :p,
-           type: :string,
-           default: 'default',
-           desc: 'Lookup policy'
-    option :namespace,
-           aliases: :n,
-           type: :string,
-           default: '',
-           desc: 'Lookup namespace'
-    option :type,
-           aliases: :t,
-           type: :string,
-           default: 'first',
-           desc: 'Lookup type'
-    option :scope,
-           aliases: :s,
-           type: :string,
-           desc: 'Scope handler',
-           default: "metadata"
-    option :scope_options,
-           type: :hash,
-           desc: "Key/value pairs to be passed to the scope handler"
-    option :merge_type,
-           aliases: :m,
-           type: :string,
-           default: 'array',
-           desc: 'Merge type'
-    option :log_level,
-           aliases: :l,
-           type: :string,
-           desc: 'Log level'
-    option :verbose,
-           aliases: :v,
-           type: :boolean,
-           desc: "Print verbose information"
-    option :debug,
-           aliases: :D,
-           type: :boolean,
-           desc: 'Debug information to console, implies --log-level debug'
-    option :trace,
-           type: :boolean,
-           desc: 'Output stacktrace to stdout'
-    option :metadata,
-           aliases: :d,
-           type: :hash,
-           desc: 'Key/value pairs to be used as metadata for the lookup'
-    option :schema,
-           aliases: :S,
-           type: :boolean,
-           desc: 'Enable/disable schema lookup, default true',
-           default: true
-    option :output,
-           aliases: :o,
-           type: :string,
-           default: 'json',
-           desc: 'Output format, yaml or json'
-
-
-    def lookup(key)
-      # 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
-
-      case true
-      when options[:verbose]
-        loglevel = "verbose"
-        logfile  = STDOUT
-      when options[:debug]
-        loglevel = "debug"
-        logfile  = STDOUT
-      else
-        logfile = nil
-        loglevel = options[:log_level]
-      end
-
-      begin
-
-        jac = Jerakia.new({
-          :config   => options[:config],
-          :logfile  => logfile,
-          :loglevel => loglevel,
-          :trace    => options[:trace],
-        })
-        req = Jerakia::Request.new(
-          :key           => key.dup,
-          :namespace     => options_copy[:namespace].split(/::/),
-          :policy        => options_copy[:policy].to_sym,
-          :lookup_type   => options_copy[:type].to_sym,
-          :merge         => options_copy[:merge_type].to_sym,
-          :metadata      => options_copy[:metadata] || {},
-          :scope         => options_copy[:scope].to_sym,
-          :scope_options => options_copy[:scope_options],
-          :use_schema    => options_copy[:schema],
-        )
-
-
-        answer = jac.lookup(req)
-        case options[:output]
-        when 'json'
-          puts answer.payload.to_json
-        when 'yaml'
-          puts answer.payload.to_yaml
-        end
-      rescue Jerakia::Error => e
-        STDERR.puts "Error(#{e.class}): #{e.message}"
-        STDERR.puts e.backtrace.join("\n") if options[:trace]
-        exit 1
-      end
-    end
+    include Jerakia::CLI::Server
+    include Jerakia::CLI::Lookup
+    include Jerakia::CLI::Token
 
     desc 'version', 'Version information'
     def version

data/lib/jerakia/config.rb

@@ -5,11 +5,9 @@ class Jerakia::Config
   attr_reader :server_url
 
   def self.load_from_file(file = '/etc/jerakia/jerakia.yaml')
-    begin
-      new YAML.load_file(file)
-    rescue Psych::SyntaxError => e
-      raise Jerakia::FileParseError, "Could not parse config file #{file}, #{e.message}"
-    end
+    new YAML.load_file(file)
+  rescue Psych::SyntaxError => e
+    raise Jerakia::FileParseError, "Could not parse config file #{file}, #{e.message}"
   end
 
   def initialize(config = {})
@@ -24,6 +22,8 @@ class Jerakia::Config
       'policydir'     => '/etc/jerakia/policy.d',
       'logfile'       => '/var/log/jerakia.log',
       'loglevel'      => 'info',
+      'vardir'        => '/var/lib/jerakia',
+      'piddir'        => '/var/run',
       'enable_schema' => true,
     }
   end

data/lib/jerakia/datasource/dummy.rb

@@ -1,17 +1,12 @@
 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" }  
+      option :return, :type => [String, Hash, Array], :default => 'Returned data'
       response.submit options[:return]
-      
-
-      
     end
   end
 end
-

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

@@ -1,8 +1,7 @@
 class Jerakia::Datasource
   module File
     class Json
-
-      EXTENSION='json'
+      EXTENSION = 'json'.freeze
 
       class << self
         require 'json'
@@ -18,4 +17,3 @@ class Jerakia::Datasource
     end
   end
 end
-

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

@@ -1,8 +1,7 @@
 class Jerakia::Datasource
   module File
     class Yaml
-
-      EXTENSION='yaml'
+      EXTENSION = 'yaml'.freeze
 
       class << self
         require 'yaml'
@@ -18,4 +17,3 @@ class Jerakia::Datasource
     end
   end
 end
-

data/lib/jerakia/datasource/file.rb

@@ -1,70 +1,51 @@
 require 'jerakia/cache/file'
 
-
 class Jerakia::Datasource
   module File
-
     attr_reader :file_format
-    @@cache = Jerakia::Cache::File.new
 
     def load_format_handler
       format = options[:format] || :yaml
-      class_name=format.to_s.capitalize
-      require "jerakia/datasource/file/#{format.to_s}"
+      class_name = format.to_s.capitalize
+      require "jerakia/datasource/file/#{format}"
       @file_format = eval "Jerakia::Datasource::File::#{class_name}"
     end
 
-
     def cache
-      @@cache
-    end
-
-    def import_file(filename)
-      Jerakia.log.debug("import_file() Importing #{filename}")
-      if ::File.exists?(filename)
-        ::File.read(filename)
-      else
-        ""
-      end
+      Jerakia::Cache::File
     end
 
     def get_file_with_cache(diskname)
       if options[:enable_caching]
-        if cache.valid?(diskname)
-          Jerakia.log.debug("Returning cached data")
-          cache.get(diskname)
-        else
-          Jerakia.log.debug("Adding contents of #{diskname} to cache")
-          cache.add(diskname,import_file(diskname))
-        end
+        Jerakia.log.debug("Querying cache for file #{diskname}")
+        cache.retrieve(diskname)
       else
-        import_file(diskname)
+        ::File.read(diskname) if ::File.exists?(diskname)
       end
     end
 
-    def list_fragments(prefix,extension)
-      if ::File.directory?("#{prefix}.d")
-        Dir["#{prefix}.d/*.#{extension}"]
-      end
+    def list_fragments(prefix, extension)
+      Dir["#{prefix}.d/*.#{extension}"] if ::File.directory?("#{prefix}.d")
     end
 
     def read_from_file(fname)
       fpath = []
       fpath << options[:docroot] unless fname[0] == '/'
-      fpath << [ fname, lookup.request.namespace ]
+      fpath << [fname, lookup.request.namespace]
 
       extension = options[:extension] || @file_format::EXTENSION
-      diskname_prefix = "#{::File.join(fpath.flatten).gsub(/\/$/, '')}"
+      diskname_prefix = ::File.join(fpath.flatten).gsub(/\/$/, '').to_s
       diskname = "#{diskname_prefix}.#{extension}"
-      
-      files = [ diskname ]
+
+      files = [diskname]
       files << list_fragments(diskname_prefix, extension)
-      
-      raw_data=""
+
+      raw_data = ''
 
       files.flatten.compact.each do |f|
         Jerakia.log.debug("read_from_file()  #{f}")
-        raw_data << get_file_with_cache(f)
+        file_contents = get_file_with_cache(f)
+        raw_data << file_contents if file_contents
       end
 
       begin
@@ -72,34 +53,30 @@ class Jerakia::Datasource
       rescue Jerakia::FileParseError => e
         raise Jerakia::FileParseError, "While parsing #{diskname}: #{e.message}"
       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 }
+      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)
+        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
       end
-      
     end
   end
 end
-

data/lib/jerakia/datasource/http.rb

@@ -1,34 +1,30 @@
 require 'lookup_http'
 
-
 class Jerakia::Datasource
   module Http
-
     def run
       #
       # Do the lookup
 
       Jerakia.log.debug("Searching key #{lookup.request.key} using the http datasource (#{whoami})")
 
-
-      option :host,                { :type => String,  :mandatory => true }
-      option :port,                { :type => Integer, :default => 80 }
-      option :output,              { :type => String,  :default => 'json' }
-      option :failure,             { :type => String,  :default => 'graceful' }
-      option :ignore_404,          { :default => true }
-      option :headers,             { :type => Hash }
-      option :http_read_timeout,   { :type => Integer }
+      option :host,                :type => String,  :mandatory => true
+      option :port,                :type => Integer, :default => 80
+      option :output,              :type => String,  :default => 'json'
+      option :failure,             :type => String,  :default => 'graceful'
+      option :ignore_404,          :default => true
+      option :headers,             :type => Hash
+      option :http_read_timeout,   :type => Integer
       option :use_ssl
-      option :ssl_ca_cert,         { :type => String }
-      option :ssl_cert,            { :type => String }
-      option :ssl_key,             { :type => String }
+      option :ssl_ca_cert,         :type => String
+      option :ssl_cert,            :type => String
+      option :ssl_key,             :type => String
       option :ssl_verify
       option :use_auth
-      option :auth_user,           { :type => String }
-      option :auth_pass,           { :type => String }
-      option :http_connect_timeout,{ :type => Integer }
-      option :paths,               { :type => Array, :mandatory => true }
-
+      option :auth_user,           :type => String
+      option :auth_pass,           :type => String
+      option :http_connect_timeout, :type => Integer
+      option :paths, :type => Array, :mandatory => true
 
       lookup_supported_params = [
         :host,
@@ -46,7 +42,7 @@ class Jerakia::Datasource
         :ssl_verify,
         :use_auth,
         :auth_user,
-        :auth_pass,
+        :auth_pass
       ]
       lookup_params = options.select { |p| lookup_supported_params.include?(p) }
       http_lookup = LookupHttp.new(lookup_params)
@@ -55,7 +51,7 @@ class Jerakia::Datasource
         Jerakia.log.debug("Attempting to load data from #{path}")
         return unless response.want?
 
-        data=http_lookup.get_parsed(path)
+        data = http_lookup.get_parsed(path)
         Jerakia.log.debug("Datasource provided #{data} (#{data.class}) looking for key #{lookup.request.key}")
 
         if data.is_a?(Hash)
@@ -64,14 +60,12 @@ class Jerakia::Datasource
             response.submit data[lookup.request.key]
           end
         else
-          unless options[:output] == 'plain' or options[:failure] == 'graceful'
+          unless options[:output] == 'plain' || options[:failure] == 'graceful'
             raise Jerakia::Error, "HTTP request did not return a hash for #{lookup.request.key} #{whoami}"
           end
           response.submit data
         end
-
       end
     end
   end
 end
-

data/lib/jerakia/datasource.rb

@@ -1,48 +1,49 @@
+# rubocop:disable Lint/Eval
+#
 require 'jerakia/cache'
-class Jerakia::Datasource 
+class Jerakia
+  class Datasource
+    require 'jerakia/response'
 
-  require 'jerakia/response'
-  attr_reader :response
-  attr_reader :options
-  attr_reader :lookup
+    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.to_s}"
-      eval "extend Jerakia::Datasource::#{name.to_s.capitalize}"
-    rescue LoadError => e
-      raise Jerakia::Error, "Cannot load datasource #{name.to_s} in lookup #{lookup.name}, #{e.message}"
+    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}"
+      end
     end
-  end
 
+    ## used for verbose logging
+    def whoami
+      "datasource=#{@name}  lookup=#{@lookup.name}"
+    end
 
-  ## used for verbose logging
-  def whoami
-    "datasource=#{@name}  lookup=#{@lookup.name}"
-  end
+    def option(opt, data = {})
+      if @options[opt].nil? && data.key?(:default)
+        @options[opt] = data[:default]
+      end
 
-  def option(opt, data={})
-    if @options[opt].nil? and data.key?(:default)
-      @options[opt] = data[:default]
-    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].to_s}  for datasource #{@name} in lookup #{lookup.name}"
+      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}"
+          end
         end
       end
     end
   end
-    
-          
 end
-

data/lib/jerakia/dsl/lookup.rb

@@ -1,14 +1,13 @@
 class Jerakia
   module Dsl
     class Lookup
-
       attr_reader :policy
       attr_reader :request
       attr_accessor :lookup
 
-      def initialize(name, policy, opts={})
+      def initialize(name, policy, opts = {})
         @policy = policy
-        @request =  policy.clone_request
+        @request = policy.clone_request
         scope   = policy.scope
         @lookup = Jerakia::Lookup.new(name, opts, @request, scope)
       end
@@ -21,9 +20,9 @@ class Jerakia
 
       # define the data source for the lookup
       # @api: public
-      def datasource(name, opts={})
+      def datasource(name, opts = {})
         datasource = Jerakia::Datasource.new(name, lookup, opts)
-        lookup.datasource=(datasource)
+        lookup.datasource = datasource
       end
 
       # give access to the lookup scope object
@@ -61,7 +60,6 @@ class Jerakia
       def plugin
         lookup.plugin
       end
-
     end
   end
 end

data/lib/jerakia/dsl/policy.rb

@@ -1,7 +1,8 @@
+require 'jerakia/cache/file'
+
 class Jerakia
   module Dsl
     class Policy
-
       def self.evaluate_file(filename, request)
         policy = new(request)
         policy.evaluate_file(filename)
@@ -18,27 +19,26 @@ class Jerakia
       attr_reader   :instance
 
       def initialize(req)
-        @request=req
+        @request = req
       end
 
       def evaluate_file(filename)
-        begin
-          policydata=Jerakia.filecache(filename)
-        rescue Jerakia::Error => e
-          raise Jerakia::PolicyError, "Could not load policy file, #{e.message}"
+        policydata = Jerakia::Cache::File.retrieve(filename)
+
+        unless policydata
+          raise Jerakia::PolicyError, "Could not load policy file, #{filename}"
         end
+
         instance_eval policydata
       end
 
-      def policy(name, opts={}, &block)
+      def policy(name, opts = {}, &block)
         @instance = Jerakia::Policy.new(name, opts, request)
-        Jerakia::Dsl::Policyblock.evaluate(instance,&block)
+        Jerakia::Dsl::Policyblock.evaluate(instance, &block)
       end
-      
     end
 
     class Policyblock
-
       attr_accessor :policy
 
       def initialize(policy)
@@ -50,10 +50,9 @@ class Jerakia
         policyblock.instance_eval &block
       end
 
-      def lookup(name, opts={}, &block)
+      def lookup(name, opts = {}, &block)
         Jerakia::Dsl::Lookup.evaluate(name, policy, opts, &block)
       end
     end
   end
-
 end

data/lib/jerakia/error.rb

@@ -1,14 +1,10 @@
 class Jerakia
   class Error < RuntimeError
-
     def initialize(msg)
       super(msg)
     end
-
   end
 
-  
-
   class PolicyError < Jerakia::Error
   end
 
@@ -18,4 +14,3 @@ class Jerakia
   class FileParseError < Jerakia::Error
   end
 end
-

data/lib/jerakia/launcher.rb

@@ -1,35 +1,31 @@
-# Here we take a request object and read in the policy file
-# which is evalulated in this instance
-#
 require 'jerakia/dsl/policy'
 require 'jerakia/dsl/lookup'
 
-class Jerakia::Launcher
-
-  attr_reader :request
-  attr_reader :answer
-
-  def initialize(req)
-    @request = req
-  end
-
-
-  def evaluate(&block)
-    policy = Jerakia::Dsl::Policy.evaluate(request, &block)
-    policy.fire!
-    @answer = policy.answer
-  end
-
-  def invoke_from_file
-    policy_name=request.policy.to_s
-    Jerakia.log.debug "Invoked lookup for #{request.key} using policy #{policy_name}"
-    filename=File.join(Jerakia.config.policydir, "#{policy_name}.rb")
-    policy = Jerakia::Dsl::Policy.evaluate_file(filename, request)
-    policy.fire!
-    @answer = policy.answer
+# Here we take a request object and read in the policy file
+# which is evalulated in this instance
+#
+class Jerakia
+  class Launcher
+    attr_reader :request
+    attr_reader :answer
+
+    def initialize(req)
+      @request = req
+    end
+
+    def evaluate(&block)
+      policy = Jerakia::Dsl::Policy.evaluate(request, &block)
+      policy.execute
+      @answer = policy.answer
+    end
+
+    def invoke_from_file
+      policy_name = request.policy.to_s
+      Jerakia.log.debug "Invoked lookup for #{request.key} using policy #{policy_name}"
+      filename = File.join(Jerakia.config.policydir, "#{policy_name}.rb")
+      policy = Jerakia::Dsl::Policy.evaluate_file(filename, request)
+      policy.execute
+      @answer = policy.answer
+    end
   end
-
 end
-
-
-