jerakia 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 691dd2bc7adfbd791cfff7d5e1e81721567d0684
-  data.tar.gz: 987421a97b12e0803be5562656d5c92b916ae326
+  metadata.gz: a9f2853d09f628caae07235bf40b294e2025dce4
+  data.tar.gz: b349c9f8181a4e47a44b53bf9d74602dfcbc2199
 SHA512:
-  metadata.gz: 2e6dab70dc4cd75bd53a8e697c2dbca44a2de610f99d9f1da6875cd8b6a788caa9d2ab3ec4cd9367a1379929dc88b2e04caa3758eda7622b9097c410f8634764
-  data.tar.gz: acf4f2caacbbdd93d65a7225b7f1ae1777e4398993b23dd05e0ba6be5af6bd9dcc7eae2a9cb080916b6cacf2439481f7f3a435ea2d25ba5f453ab77f6b5576b2
+  metadata.gz: 51b217b1c2a946378a4fd8947de57277bc74d2b1dfe659ca8363314b8ecf28b3905b960c04e5b0cece3063d5402fa9b862238fdde2a43755b8a2b9dd4fe38de3
+  data.tar.gz: 3f35a0de6e1b987c41652e572ad31ecdd4aab804e109caae2729728bdb5a319227e626c7e2e1841ce6888e94b9258a2dc4890d20d71dee6b8d4c996b48f61fdb

data/lib/hiera/backend/jerakia_backend.rb

@@ -4,16 +4,15 @@ require 'puppet/resource'
 class Hiera
   module Backend
     class Jerakia_backend
-
       def initialize(config = nil)
         require 'jerakia'
-        @config = config || Hiera::Config[:jerakia] || {} 
+        @config = config || Hiera::Config[:jerakia] || {}
         @policy = @config[:policy] || 'default'
         @jerakia = ::Jerakia.new(@config)
         Jerakia.log.debug("[hiera] hiera backend loaded with policy #{@policy}")
       end
 
-      def lookup(key, scope, order_override, resolution_type)
+      def lookup(key, scope, _order_override, resolution_type)
         lookup_type = :first
         merge_type = :none
 
@@ -29,27 +28,27 @@ class Hiera
         namespace = []
 
         if key.include?('::')
-           lookup_key = key.split('::')
-           key = lookup_key.pop
-           namespace = lookup_key
+          lookup_key = key.split('::')
+          key = lookup_key.pop
+          namespace = lookup_key
         end
 
         Jerakia.log.debug("[hiera] backend invoked for key #{key} using namespace #{namespace}")
 
-        metadata={}
-        if scope.is_a?(Hash)
-          metadata=scope.reject { |k, v| v.is_a?(Puppet::Resource) }
-        else
-          metadata = scope.real.to_hash.reject { |k, v| v.is_a?(Puppet::Resource) }
-        end
+        metadata = {}
+        metadata = if scope.is_a?(Hash)
+                     scope.reject { |_k, v| v.is_a?(Puppet::Resource) }
+                   else
+                     scope.real.to_hash.reject { |_k, v| v.is_a?(Puppet::Resource) }
+                   end
 
         request = Jerakia::Request.new(
           :key         => key,
           :namespace   => namespace,
-          :policy      => metadata["jerakia_policy"] || @policy,
+          :policy      => metadata['jerakia_policy'] || @policy,
           :lookup_type => lookup_type,
           :merge       => merge_type,
-          :metadata    => metadata,
+          :metadata    => metadata
         )
 
         answer = @jerakia.lookup(request)

data/lib/jerakia/answer.rb

@@ -1,29 +1,31 @@
-class Jerakia::Answer
+class Jerakia
+  class Answer
+    require 'deep_merge'
 
-  require 'deep_merge'
+    attr_accessor :payload
+    attr_accessor :datatype
+    attr_reader :lookup_type
 
-  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"
+    def initialize(lookup_type = :first)
+      case lookup_type
+      when :first
+        @payload = nil
+      when :cascade
+        @payload = []
+        @datatype = 'array'
+      end
     end
-  end
 
-  def flatten_payload!
-    @payload.flatten!
-  end
+    def flatten_payload!
+      @payload.flatten!
+    end
 
-  def merge_payload!(method = :hash)
-    payload_hash={}
-    @payload.each do |p|
-      if p.is_a?(Hash)
+    # TODO: consolidate this into less lines
+    #
+    def merge_payload!(method = :hash) # rubocop:disable Metrics/MethodLength
+      payload_hash = {}
+      @payload.each do |p|
+        next unless p.is_a?(Hash)
         case method
         when :hash
           payload_hash = p.merge(payload_hash)
@@ -31,13 +33,12 @@ class Jerakia::Answer
           payload_hash = p.deep_merge!(payload_hash)
         end
       end
+      @payload = payload_hash
+      set_data_type
     end
-    @payload=payload_hash
-    set_data_type
-  end
 
-  def set_data_type
-    @data_type=@payload.class.to_s.downcase
+    def set_data_type
+      @data_type = @payload.class.to_s.downcase
+    end
   end
 end
-

data/lib/jerakia/cache/entry.rb

@@ -1,17 +1,13 @@
 class Jerakia::Cache::Entry
-
   attr_accessor :key
   attr_accessor :content
   @@cache = Jerakia::Cache.new
 
-  def initialize(key='', content='')
-    @@cache.add(key, self)   
+  def initialize(key = '', _content = '')
+    @@cache.add(key, self)
   end
 
   def valid?
     true
   end
 end
-
-
-

data/lib/jerakia/cache/file.rb

@@ -1,33 +1,63 @@
 require 'jerakia/cache'
 
-class Jerakia::Cache::File < Jerakia::Cache
-  
-  
-  def initialize
-    super
-  end
+class Jerakia::Cache::File
+  class << self
+    def cache
+      Jerakia::Cache
+    end
 
+    # Returns the latest mtime of the file if the file exists and
+    # nil if it doesn't exist.
+    #
+    def state(filename)
+      ::File.stat(filename).mtime if ::File.exist?(filename)
+    end
 
-  def state(filename)
-    if ::File.exists?(filename)
-      ::File.stat(filename).mtime
-    else
-      nil
+    def add(index, data)
+      filestate = state(index)
+      Jerakia.log.debug("Adding #{index} to file cache with state #{filestate}")
+      cache.add(index, data, :state => filestate) if filestate
     end
-  end
 
-  def add(index,data)
-    @@bucket[index] ||= {}
-    @@bucket[index][:state] = state(index)
-    super
-  end
+    def valid?(index)
+      if cache.in_bucket?(index)
+        unless File.exists?(index)
+          cache.purge(index)
+          return false
+        end
+        metadata = cache.metadata(index)
+        if metadata
+          metadata[:state] == state(index)
+        else
+          false
+        end
+      else
+        false
+      end
+    end
 
-  def valid?(index)
-    if in_bucket?(index)
-      @@bucket[index][:state] == state(index)
-    else
-      false
+    def import_file(filename)
+      Jerakia.log.debug("Importing file #{filename} to file cache")
+      File.read(filename)
+    end
+
+    # If the cache has a valid copy of the file, then we retrieve it, if the cache
+    # doesn't have a copy, or if the state has changed, then we should add it to 
+    # the cache again and overite the existing data.
+    # 
+    # Returns nil if the file doesn't exist
+    #
+    def retrieve(filename)
+      if valid?(filename)
+        Jerakia.log.debug("Using cached contents of #{filename}")
+        get(filename)
+      else
+        add(filename, import_file(filename)) if File.exists?(filename)
+      end
     end
-  end
 
+    def get(index)
+      cache.get(index)
+    end
+  end
 end

data/lib/jerakia/cache.rb

@@ -3,38 +3,71 @@
 #
 #
 class Jerakia::Cache
+  @bucket = {}
 
-  @@bucket = {}
+  class << self
+    attr_reader :bucket
+  end
 
   def initialize
   end
 
-  def add(index,data)
-    @@bucket[index] ||= {}
+  def add(index, data, metadata={})
+    self.class.add(index,data, metadata)
+  end
+
+  def self.add(index, data, metadata={})
+    @bucket[index] ||= {}
     ## The cache bucket is a global class object, therefore we should
     ## always store a copy of the data object, not the actual object
     ## to ensure that it is not referenced and tainted by the lookup
     #
-    @@bucket[index][:content] = Marshal::load(Marshal.dump(data))
-    data
+    set_metadata(index, metadata)
+    @bucket[index][:content] = Marshal.load(Marshal.dump(data))
+  end
+
+  def self.set_metadata(index, metadata)
+    @bucket[index][:metadata] = Marshal.load(Marshal.dump(metadata))
   end
 
+  def self.metadata(index)
+    if in_bucket?(index)
+      Marshal.load(Marshal.dump(@bucket[index][:metadata]))
+    end
+  end
+
+
   def in_bucket?(index)
-    @@bucket.has_key?(index)
+    self.class.in_bucket?(index)
+  end
+
+  def self.in_bucket?(index)
+    bucket.has_key?(index)
   end
 
   ## default behaviour is always validate if exists.
   def valid?(index)
     in_bucket?(index)
   end
-  
+
+  def purge(index)
+    self.class.purge(index)
+  end
+
+  def self.purge(index)
+    @bucket.delete(index)
+  end
+
   def get(index)
-    data = @@bucket[index][:content]
-    Marshal::load(Marshal.dump(data))
+    self.class.get(index)
+  end
+
+  def self.get(index)
+    data = @bucket[index][:content]
+    Marshal.load(Marshal.dump(data))
   end
 
   def bucket
-    @@bucket
+    self.class.bucket
   end
 end
-

data/lib/jerakia/cli/lookup.rb

@@ -0,0 +1,124 @@
+class Jerakia
+  class CLI < Thor
+    module Lookup
+      def self.included(thor)
+        thor.class_eval do
+          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,
+                 efault: '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
+              else
+                puts answer.payload
+              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
+        end
+      end
+    end
+  end
+end

data/lib/jerakia/cli/server.rb

@@ -0,0 +1,50 @@
+class Jerakia
+  class CLI < Thor
+    module Server
+      def self.included(thor)
+        thor.class_eval do
+          desc 'server', 'Start the Jerakia REST server'
+          option :config,
+                 aliases: :c,
+                 type: :string,
+                 desc: 'Configuration file'
+          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'
+          def server
+            case true
+            when options[:verbose]
+              loglevel = 'verbose'
+              logfile  = STDOUT
+            when options[:debug]
+              loglevel = 'debug'
+              logfile  = STDOUT
+            else
+              logfile = nil
+              loglevel = options[:log_level]
+            end
+
+            jerakia_opts = {
+              :config => options[:config],
+              :logfile  => logfile,
+              :loglevel => loglevel,
+              :trace    => options[:trace]
+            }
+
+            require 'jerakia/server'
+            Jerakia::Server.start(jerakia_opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jerakia/cli/token.rb

@@ -0,0 +1,64 @@
+class Jerakia
+  class CLI < Thor
+    module Token
+      def self.included(thor)
+        thor.class_eval do
+          desc 'token [SUBCOMMAND] <api id> <options>', 'Create, view and manage token access'
+          option :quiet,
+                 aliases: :q,
+                 type: :boolean,
+                 desc: 'Supress explanatory output'
+
+          def token(subcommand, api_id=:all)
+            Jerakia.new
+            require 'jerakia/server/auth'
+
+            unless subcommand == 'list'
+              if api_id == :all
+                help :token
+                STDERR.puts "Error: No API ID provided"
+                exit 1
+              end
+            end
+
+            if ['enable', 'disable', 'regenerate', 'delete'].include?(subcommand)
+              unless Jerakia::Server::Auth.exists?(api_id)
+                STDERR.puts "No such API ID #{api_id}"
+                exit 1
+              end
+            end
+
+            case subcommand
+            when 'create'
+              token = Jerakia::Server::Auth.create(api_id)
+              unless options[:quiet]
+                puts "Copy the following token to the application, it must be sent in the Authorization header. This token cannot be retrieved later, if you have lost the token for an application you can create a new one with 'jerakia token regenerate <api id>'\n\n"
+              end
+              puts token
+
+            when 'list'
+              entries = Jerakia::Server::Auth.get_tokens
+              printf("%-20s %-28s %s\n\n","API Identifier","Last Seen", "Status")
+              entries.each do |entry|
+                status = entry.active ? 'active' : 'disabled'
+                printf("%-20s %-28s %s\n", entry.api_id, entry.last_seen.strftime('%F %X'), status)
+              end
+
+            when 'disable'
+              Jerakia::Server::Auth.disable(api_id)
+            when 'enable'
+              Jerakia::Server::Auth.enable(api_id)
+            when 'delete'
+              Jerakia::Server::Auth.destroy(api_id)
+            when 'regenerate'
+              token('delete', api_id)
+              token('create', api_id)
+            else
+              STDERR.puts "Unknown subcommand #{subcommand}.  Valid commands are list, create, delete, regenerate, disable, enable"
+            end
+          end
+        end
+      end
+    end
+  end
+end