smart_proxy_openbolt 0.1.1 → 1.2.0

data/lib/smart_proxy_openbolt/job.rb

@@ -1,9 +1,9 @@
-require 'net/http'
 require 'smart_proxy_openbolt/result'
-require 'thread'
 
 module Proxy::OpenBolt
   class Job
+    include ::Proxy::Log
+
     attr_accessor :id
     attr_reader :name, :parameters, :options, :status
 
@@ -35,11 +35,18 @@ module Proxy::OpenBolt
         result = execute
         update_status(result.status)
         store_result(result)
-      rescue => e
-        # This should never happen, but just in case we made a coding error,
-        # expose something in the result.
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        # Catch everything including non-StandardError exceptions (e.g.
+        # ScriptError) so the job always gets a terminal status.
         update_status(:exception)
-        store_result({message: e.full_message, backtrace: e.backtrace})
+        logger.error("Job #{@id} failed (#{e.class}): #{e.message}")
+        logger.debug(e.backtrace.join("\n")) if e.backtrace
+        begin
+          store_result({ message: e.full_message, backtrace: e.backtrace })
+        rescue StandardError => store_error
+          logger.error("Job #{@id}: failed to store error result: #{store_error.message}")
+          logger.debug(store_error.backtrace.join("\n")) if store_error.backtrace
+        end
       end
     end
 
@@ -48,84 +55,13 @@ module Proxy::OpenBolt
     end
 
     def store_result(value)
-      # On disk
-      results_file = "#{Proxy::OpenBolt::Plugin.settings.log_dir}/#{@id}.json"
-      File.open(results_file, 'w') { |f| f.write(value.to_json) }
-
-      # Send to reports API
-      #reports = get_reports(value)
-
-      # TODO: Figure out how to authenticate with the /api/config_reports endpoint
-      #reports.each do |report|
-      #  foreman = Proxy::SETTINGS.foreman_url
-        # Send it
-      #  puts foreman
-      #end
-    end
-
-    def log_item(text, level)
-      { 
-        'log': {
-          'sources': {
-            'source': 'OpenBolt'
-          },
-          'messages': {
-            'message': text
-          },
-          'level': level
-        }
-      }
+      File.write(Proxy::OpenBolt.result_file_path(@id), value.to_json)
     end
 
-    def get_reports(value)
-      command = value.command
-      log = value.log
-      items = value.value['items']
-      return nil if items.nil?
-      timestamp = Time.now.utc
-
-      source = { 'sources': { 'source': 'OpenBolt' } }
-      items.map do |item|
-        target = item['target']
-        status = item['status']
-        data = item['value']
-        message = item['message']
-        logs = [log_item("Command: #{command}", 'info')]
-        if data['_error']
-          kind = data.dig('_error','kind')
-          msg = data.dig('_error', 'msg')
-          issue_code = data.dig('_error', 'issue_code')
-          logs << log_item("Error kind: #{kind}", 'error')
-          logs << log_item("Error mesage: #{msg}", 'error')
-          logs << log_item("Error issue code: #{issue_code}", 'error')
-        end
-        logs << log_item("Result: #{data}", 'info')
-        logs << log_item("Task run log: #{log}", 'info') if log
-        logs << log_item("Message: #{message}", 'info') if message
-        {
-          'config_report': {
-            'host': target,
-            'reported_at': timestamp,
-            'status': {
-              "applied": status == 'success' ? 1 : 0,
-              "failed": status == 'failure' ? 1 : 0,
-            },
-            'logs': logs
-          }
-        }
-      end
-      items
-    end
-        
-        
-
-
-    # At the moment, always read back from the file so we don't store a bunch
-    # of huge results in memory. Once we are database-backed, this is less
-    # cumbersome and problematic.
+    # Read the result back from disk as a raw JSON string. We avoid parsing
+    # and re-serializing since the file is already valid JSON.
     def result
-      results_file = "#{Proxy::OpenBolt::Plugin.settings.log_dir}/#{@id}.json"
-      JSON.parse(File.read(results_file))
+      File.read(Proxy::OpenBolt.result_file_path(@id))
     end
   end
 end

data/lib/smart_proxy_openbolt/lru_cache.rb

@@ -0,0 +1,43 @@
+module Proxy::OpenBolt
+  # Thread-safe, size-bounded cache that evicts the least recently used
+  # entry when full. Built on Ruby's insertion-ordered Hash.
+  # Implemented here rather than pulling in a gem to avoid adding
+  # packaging dependencies for something this straightforward.
+  class LruCache
+    def initialize(max_size)
+      raise ArgumentError, 'max_size must be at least 1' if max_size < 1
+      @max_size = max_size
+      @hash = {}
+      @mutex = Mutex.new
+    end
+
+    def get(key)
+      @mutex.synchronize do
+        return nil unless @hash.key?(key)
+        # Move to end (most recently used)
+        value = @hash.delete(key)
+        @hash[key] = value
+      end
+    end
+
+    def put(key, value)
+      @mutex.synchronize do
+        @hash.delete(key) if @hash.key?(key)
+        @hash[key] = value
+        @hash.shift if @hash.size > @max_size
+      end
+    end
+
+    def delete(key)
+      @mutex.synchronize { @hash.delete(key) }
+    end
+
+    def key?(key)
+      @mutex.synchronize { @hash.key?(key) }
+    end
+
+    def size
+      @mutex.synchronize { @hash.size }
+    end
+  end
+end