foreman_openbolt 0.0.1

data/Rakefile

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# !/usr/bin/env rake
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ForemanOpenbolt'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  puts 'Rubocop not loaded.'
+end
+
+# This is all kinda screwy. Fix it up later.
+LINTERS = {
+  ruby: { cmd: 'rubocop', fix: '--auto-correct' },
+  erb: { cmd: 'erb_lint', fix: '--autocorrect', glob: '**/*.erb' },
+  js: { image: 'registry.access.redhat.com/ubi9/nodejs-20:latest', cmd: 'npm run lint --', fix: '--fix' },
+}.freeze
+
+namespace :lint do
+  def fix?
+    !ENV['FIX'].nil?
+  end
+
+  def local?
+    !ENV['LOCAL'].nil?
+  end
+
+  def bin
+    ENV['CONTAINER_BIN'] || 'docker'
+  end
+
+  LINTERS.each do |name, cfg|
+    desc "Run #{name} linter#{' (fix)' if fix?}"
+    task name do
+      cmd = [cfg[:cmd]]
+      cmd << cfg[:fix] if fix?
+      cmd << cfg[:glob] unless cfg[:glob].nil? || cfg[:glob].empty? # rubocop:disable Rails/Blank
+      cmd = cmd.join(' ')
+      if cfg[:image] && !local?
+        cmd = "#{bin} run --rm -v #{Dir.pwd}:/code #{cfg[:image]} /bin/bash -c " +
+              "'cd /code && npm install --loglevel=error && #{cmd}'"
+      end
+      sh cmd
+    end
+  end
+
+  desc 'Run all linters'
+  task all: LINTERS.keys
+
+  desc 'Run all linters and apply fixes'
+  task :fix do
+    ENV['FIX'] = 'true'
+    Rake::Task['lint:all'].invoke
+  end
+end
+
+task default: ['lint:all', 'test']
+
+begin
+  require 'rubygems'
+  require 'github_changelog_generator/task'
+
+  GitHubChangelogGenerator::RakeTask.new :changelog do |config|
+    config.exclude_labels = %w[duplicate question invalid wontfix wont-fix skip-changelog github_actions]
+    config.user = 'overlookinfra'
+    config.project = 'foreman_openbolt'
+    gem_version = Gem::Specification.load("#{config.project}.gemspec").version
+    config.future_release = gem_version
+  end
+rescue LoadError
+  task :changelog do
+    abort("Run `bundle install --with release` to install the `github_changelog_generator` gem.")
+  end
+end

data/app/controllers/foreman_openbolt/task_controller.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'foreman_openbolt/engine'
+require 'proxy_api/openbolt'
+
+module ForemanOpenbolt
+  class TaskController < ::ApplicationController
+    include ::Foreman::Controller::AutoCompleteSearch
+
+    # For passing to/from the UI
+    ENCRYPTED_PLACEHOLDER = '[Use saved encrypted default]'
+    # For saving to the database
+    REDACTED_PLACEHOLDER = '*****'
+
+    before_action :load_smart_proxy, only: [
+      :fetch_tasks, :reload_tasks, :fetch_openbolt_options, :launch_task, :job_status, :job_result
+    ]
+    before_action :load_openbolt_api, only: [
+      :fetch_tasks, :reload_tasks, :fetch_openbolt_options, :launch_task, :job_status, :job_result
+    ]
+    before_action :load_task_job, only: [:job_status, :job_result]
+
+    # React-rendered pages
+    def page_launch_task
+      render 'foreman_openbolt/react_page'
+    end
+
+    def page_task_execution
+      render 'foreman_openbolt/react_page'
+    end
+
+    def page_task_history
+      render 'foreman_openbolt/react_page'
+    end
+
+    def fetch_tasks
+      render_openbolt_api_call(:tasks)
+    end
+
+    def reload_tasks
+      render_openbolt_api_call(:reload_tasks)
+    end
+
+    def fetch_openbolt_options
+      options = @openbolt_api.openbolt_options
+
+      # Get defaults from Foreman settings
+      defaults = {}
+      openbolt_settings.each do |setting|
+        key = setting.name.sub(/^openbolt_/, '')
+        defaults[key] = setting.encrypted? ? ENCRYPTED_PLACEHOLDER : setting.value if setting.value.present?
+      end
+
+      # Merge the defaults into the options metadata
+      result = {}
+      options.each do |name, meta|
+        result[name] = meta.dup
+        result[name]['default'] = defaults[name] if defaults.key?(name)
+      end
+
+      render json: result
+    rescue ProxyAPI::ProxyException => e
+      logger.error("OpenBolt API error for fetch_openbolt_options: #{e.message}")
+      render_error("Smart Proxy error: #{e.message}", :bad_gateway)
+    rescue StandardError => e
+      logger.error("Unexpected error in fetch_openbolt_options: #{e.class}: #{e.message}")
+      render_error("Internal server error: #{e.message}", :internal_server_error)
+    end
+
+    def launch_task
+      required_args = [:task_name, :targets]
+      missing_args = required_args.select { |arg| params[arg].blank? }
+
+      if missing_args.any?
+        return render_error("Missing required arguments to the launch_task function: #{missing_args.join(', ')}",
+          :bad_request)
+      end
+
+      begin
+        task_name = params[:task_name].to_s.strip
+        targets = params[:targets].to_s.strip
+        task_params = params[:params] || {}
+        options = params[:options] || {}
+        options = merge_encrypted_defaults(options)
+
+        return render_error('Task name and targets cannot be empty', :bad_request) if task_name.empty? || targets.empty?
+
+        logger.info("Launching OpenBolt task '#{task_name}' on targets '#{targets}' via proxy #{@smart_proxy.name}")
+
+        response = @openbolt_api.launch_task(
+          name: task_name,
+          targets: targets,
+          parameters: task_params,
+          options: options
+        )
+
+        logger.info("Task execution response: #{response.inspect}")
+
+        return render_error("Task execution failed: #{response['error']}", :bad_request) if response['error']
+        return render_error('Task execution failed: No job ID returned', :bad_request) unless response['id']
+
+        metadata = @openbolt_api.tasks[task_name] || {}
+        TaskJob.create_from_execution!(
+          proxy: @smart_proxy,
+          task_name: task_name,
+          task_description: metadata['description'] || '',
+          targets: targets.split(',').map(&:strip),
+          parameters: task_params,
+          options: scrub_options_for_storage(options),
+          job_id: response['id']
+        )
+
+        # Start background polling to update status
+        ForemanTasks.async_task(Actions::ForemanOpenbolt::PollTaskStatus,
+          response['id'],
+          @smart_proxy.id)
+
+        render json: {
+          job_id: response['id'],
+          proxy_id: @smart_proxy.id,
+          proxy_name: @smart_proxy.name,
+        }
+      rescue ActiveRecord::RecordInvalid => e
+        logger.error("Failed to create TaskJob: #{e.message}")
+        render_error("Database error: #{e.message}", :internal_server_error)
+      rescue StandardError => e
+        logger.error("Task launch error: #{e.class}: #{e.message}")
+        logger.error("Backtrace: #{e.backtrace.first(5).join("\n")}")
+        render_error("Error launching task: #{e.message}", :internal_server_error)
+      end
+    end
+
+    def job_status
+      return render_error('Task job not found', :not_found) unless @task_job
+
+      render json: {
+        status: @task_job.status,
+        submitted_at: @task_job.submitted_at,
+        completed_at: @task_job.completed_at,
+        duration: @task_job.duration,
+        task_name: @task_job.task_name,
+        task_description: @task_job.task_description,
+        task_parameters: @task_job.task_parameters,
+        targets: @task_job.targets,
+      }
+    end
+
+    def job_result
+      return render_error('Task job not found', :not_found) unless @task_job
+
+      render json: {
+        status: @task_job.status,
+        command: @task_job.command,
+        value: @task_job.result,
+        log: @task_job.log,
+      }
+    end
+
+    # List of all task history
+    def fetch_task_history
+      @task_history = TaskJob.includes(:smart_proxy)
+                             .recent
+                             .paginate(page: params[:page],
+                               per_page: (params[:per_page] || 20).to_i)
+
+      render json: {
+        results: @task_history.map { |job| serialize_task_job(job) },
+        total: @task_history.total_entries,
+        page: @task_history.current_page,
+        per_page: @task_history.per_page,
+      }
+    end
+
+    # Show a specific task job
+    def show
+      task_job = TaskJob.find(params[:id])
+      render json: serialize_task_job(task_job, detailed: true)
+    rescue ActiveRecord::RecordNotFound
+      render_error('Task job not found', :not_found)
+    end
+
+    private
+
+    def load_smart_proxy
+      proxy_id = params[:proxy_id]
+      if proxy_id.blank?
+        render_error('Smart Proxy ID is required', :bad_request)
+        return false
+      end
+
+      return true if @smart_proxy && @smart_proxy.id.to_s == proxy_id.to_s
+
+      @smart_proxy = SmartProxy.authorized(:view_smart_proxies).find_by(id: proxy_id)
+
+      unless @smart_proxy
+        render_error("Smart Proxy with ID #{proxy_id} not found or not authorized", :not_found)
+        return false
+      end
+
+      true
+    end
+
+    def load_openbolt_api
+      return false unless @smart_proxy
+      return true if @openbolt_api && @openbolt_api.url == @smart_proxy.url
+
+      begin
+        @openbolt_api = ProxyAPI::Openbolt.new(url: @smart_proxy.url)
+      rescue StandardError => e
+        logger.error("Failed to initialize OpenBolt API for proxy #{@smart_proxy.name}: #{e.message}")
+        render_error("Failed to connect to Smart Proxy", :bad_gateway)
+        return false
+      end
+
+      true
+    end
+
+    def load_task_job
+      job_id = params[:job_id]
+      logger.debug("load_task_job - Job ID: #{job_id}")
+      return if job_id.blank?
+
+      @task_job = TaskJob.find_by(job_id: job_id)
+      logger.debug("load_task_job - Task Job: #{@task_job.inspect}")
+    end
+
+    def openbolt_settings
+      @openbolt_settings ||= Setting.where("name LIKE 'openbolt_%'")
+    end
+
+    def encrypted_settings
+      openbolt_settings.select(&:encrypted?)
+    end
+
+    def merge_encrypted_defaults(options)
+      encrypted = options.select { |_, v| v == ENCRYPTED_PLACEHOLDER }
+      encrypted.each do |key, _|
+        setting = Setting.find_by(name: "openbolt_#{key}")
+        raise "Could not find setting called openbolt_#{key}" if setting.nil?
+        options[key] = setting.value
+      end
+      options
+    end
+
+    def scrub_options_for_storage(options)
+      scrubbed = options.dup
+      encrypted_settings.each do |setting|
+        option_name = setting.name.sub(/^openbolt_/, '')
+        scrubbed[option_name] = REDACTED_PLACEHOLDER if scrubbed.key?(option_name)
+      end
+      scrubbed
+    end
+
+    def render_openbolt_api_call(method_name, **args)
+      result = @openbolt_api.send(method_name, **args)
+      logger.debug("OpenBolt API call #{method_name} successful for proxy #{@smart_proxy.name}")
+      render json: result
+    rescue ProxyAPI::ProxyException => e
+      logger.error("OpenBolt API error for #{method_name}: #{e.message}")
+      render_error("Smart Proxy error: #{e.message}", :bad_gateway)
+    rescue StandardError => e
+      logger.error("Unexpected error in #{method_name}: #{e.class}: #{e.message}")
+      render_error("Internal server error: #{e.message}", :internal_server_error)
+    end
+
+    def render_error(message, status)
+      render json: { error: message }, status: status
+    end
+
+    def serialize_task_job(task_job, detailed: false)
+      data = {
+        job_id: task_job.job_id,
+        task_name: task_job.task_name,
+        task_description: task_job.task_description,
+        task_parameters: task_job.task_parameters,
+        targets: task_job.targets,
+        status: task_job.status,
+        smart_proxy: {
+          id: task_job.smart_proxy_id,
+          name: task_job.smart_proxy.name,
+        },
+        submitted_at: task_job.submitted_at,
+        completed_at: task_job.completed_at,
+        duration: task_job.duration,
+      }
+
+      if detailed
+        data.merge!(
+          openbolt_options: task_job.scrubbed_openbolt_options,
+          result: task_job.result,
+          log: task_job.log
+        )
+      end
+
+      data
+    end
+  end
+end

data/app/lib/actions/foreman_openbolt/cleanup_proxy_artifacts.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Actions
+  module ForemanOpenbolt
+    class CleanupProxyArtifacts < Actions::EntryAction
+      def plan(proxy_id, job_id)
+        plan_self(proxy_id: proxy_id, job_id: job_id)
+      end
+
+      def run
+        proxy = ::SmartProxy.find(input[:proxy_id])
+        api = ::ProxyAPI::Openbolt.new(url: proxy.url)
+
+        response = api.delete_job_artifacts(job_id: input[:job_id])
+        Rails.logger.info("Cleaned up artifacts for job #{input[:job_id]}: #{response}")
+
+        Rails.logger.info("Would delete artifacts for job #{input[:job_id]} on proxy #{proxy.name}")
+      rescue StandardError => e
+        # Don't fail the action if cleanup fails - it's not critical
+        Rails.logger.error("Failed to cleanup artifacts for job #{input[:job_id]}: #{e.message}")
+      end
+
+      def rescue_strategy
+        # Skip rescue - if cleanup fails, we don't want to retry
+        Dynflow::Action::Rescue::Skip
+      end
+
+      def humanized_name
+        _("Cleanup OpenBolt task artifacts")
+      end
+
+      def humanized_input
+        {
+          job_id: input[:job_id],
+          proxy: ::SmartProxy.find_by(id: input[:proxy_id])&.name,
+        }
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_openbolt/poll_task_status.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+# This is a Dynflow action that polls the status of an OpenBolt task job
+# from the Smart Proxy. It periodically checks the job status until it is
+# completed, then fetches the final results.
+module Actions
+  module ForemanOpenbolt
+    class PollTaskStatus < Actions::EntryAction
+      include Actions::RecurringAction
+
+      POLL_INTERVAL = 5.seconds
+      RETRY_LIMIT = 60 # Number of retries before giving up (5 minutes)
+
+      # Set up the action when it is first scheduled, storing
+      # IDs needed to get information from the proxy.
+      def plan(job_id, proxy_id)
+        plan_self(job_id: job_id, proxy_id: proxy_id)
+      end
+
+      # Main execution method that Dynflow will call repeatedly.
+      # event = nil when execution starts
+      # event = :poll when this is triggered by the timer
+      def run(event = nil)
+        if event.nil? || event.to_sym == :poll
+          poll_and_reschedule
+        else
+          error("Received unknown event '#{event}' for OpenBolt job #{input[:job_id]}. Finishing the action.")
+          finish
+        end
+      end
+
+      def finalize
+        Rails.logger.info("Finalized polling for OpenBolt job #{input[:job_id]}")
+      end
+
+      private
+
+      def append_output(key, message)
+        output[key] ||= []
+        output[key] << message
+      end
+
+      def log(message)
+        append_output(:log, "[#{Time.now.getlocal.strftime('%Y-%m-%d %H:%M:%S')}] #{message}")
+      end
+
+      def error(message)
+        append_output(:error, message)
+      end
+
+      def exception(e)
+        append_output(:exception, e.message)
+        append_output(:exception_backtrace, e.backtrace.join("\n"))
+      end
+
+      def finish
+        log("Polling finished for OpenBolt job #{input[:job_id]}")
+      end
+
+      def poll_and_reschedule
+        job_id = input[:job_id]
+
+        # If task doesn't exist or is already complete, finish
+        if task_job.nil? || task_job.completed?
+          finish
+          return
+        end
+
+        # If the smart proxy has been deleted somehow or is unknown,
+        # we can't poll for status, so finish.
+        if proxy.nil?
+          error("Smart Proxy with ID #{input[:proxy_id]} not found for OpenBolt job #{job_id}. Finishing the action.")
+          finish
+          return
+        end
+
+        begin
+          api = ::ProxyAPI::Openbolt.new(url: proxy.url)
+
+          # Fetch current status
+          status_result = api.job_status(job_id: job_id)
+
+          # Update status if changed
+          if status_result && status_result['status']
+            input[:retry_count] = 0
+            task_job.update!(status: status_result['status'])
+            log("Status: #{status_result['status']}")
+
+            # If completed, fetch full results
+            if task_job.completed?
+              result = api.job_result(job_id: job_id)
+              if result
+                task_job.update_from_proxy_result!(result)
+                log("OpenBolt job #{job_id} completed with status '#{task_job.status}'")
+              else
+                log("WARNING: No result returned from proxy for completed OpenBolt job #{job_id}")
+              end
+              finish
+              return
+            end
+          end
+
+          # Still running, schedule next poll in 5 seconds
+          suspend do |suspended_action|
+            world.clock.ping(suspended_action, POLL_INTERVAL.from_now.to_time, :poll)
+          end
+        rescue StandardError => e
+          error("Error polling task status for job #{job_id}")
+          exception(e)
+
+          retry_count = (input[:retry_count] || 0) + 1
+          input[:retry_count] = retry_count
+
+          if retry_count > RETRY_LIMIT
+            error("Could not successfully poll task status for job #{job_id} after #{retry_count} attempts. Giving up.")
+            finish
+            return
+          end
+
+          suspend do |suspended_action|
+            world.clock.ping(suspended_action, POLL_INTERVAL.from_now.to_time, :poll)
+          end
+        end
+      end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Skip
+      end
+
+      def humanized_name
+        _('Poll OpenBolt task execution status')
+      end
+
+      def humanized_input
+        input.slice(:job_id, :proxy_id).merge(
+          # Using & to handle possible nil values just in case
+          proxy_name: proxy&.name,
+          task_name: task_job&.task_name
+        )
+      end
+
+      def task_job
+        @task_job ||= ::ForemanOpenbolt::TaskJob.find_by(job_id: input[:job_id])
+      end
+
+      def proxy
+        @proxy ||= ::SmartProxy.find_by(id: input[:proxy_id])
+      end
+    end
+  end
+end

data/app/models/foreman_openbolt/task_job.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ForemanOpenbolt
+  class TaskJob < ApplicationRecord
+    self.table_name = 'openbolt_task_jobs'
+    self.primary_key = 'job_id'
+
+    # Constants
+    STATUSES = %w[pending running success failure exception invalid].freeze
+    COMPLETED_STATUSES = %w[success failure exception invalid].freeze
+    RUNNING_STATUSES = %w[pending running].freeze
+
+    # Associations
+    belongs_to :smart_proxy
+
+    # Validations
+    validates :task_name, presence: true
+    validates :job_id, presence: true, uniqueness: true
+    validates :status, inclusion: { in: STATUSES }
+    validates :targets, presence: true
+    validates :submitted_at, presence: true
+
+    # Scopes
+    scope :running, -> { where(status: RUNNING_STATUSES) }
+    scope :completed, -> { where(status: COMPLETED_STATUSES) }
+    scope :recent, -> { order(submitted_at: :desc) }
+    scope :for_proxy, ->(proxy) { where(smart_proxy: proxy) }
+
+    # Callbacks
+    before_validation :set_submitted_at, on: :create
+    before_update :set_completed_at, if: :status_changed_to_completed?
+    after_update :cleanup_proxy_artifacts, if: :saved_result_and_log?
+
+    # Class methods
+    def self.create_from_execution!(proxy:, task_name:, task_description:, targets:, job_id:, parameters: {}, options: {})
+      create!(
+        job_id: job_id,
+        smart_proxy: proxy,
+        task_name: task_name,
+        task_description: task_description,
+        targets: targets,
+        task_parameters: parameters,
+        openbolt_options: options,
+        status: 'pending'
+        # submitted_at is set by callback
+      )
+    end
+
+    def completed?
+      status.in?(COMPLETED_STATUSES)
+    end
+
+    def running?
+      status.in?(RUNNING_STATUSES)
+    end
+
+    def duration
+      return nil unless submitted_at && completed_at
+      completed_at - submitted_at
+    end
+
+    # Result/log will already be scrubbed by the proxy
+    def update_from_proxy_result!(proxy_result)
+      return if proxy_result.blank?
+
+      transaction do
+        self.status = proxy_result['status'] if proxy_result['status'].present?
+        self.command = proxy_result['command'] if proxy_result['command'].present?
+        self.result = proxy_result['value'] if proxy_result.key?('value')
+        self.log = proxy_result['log'] if proxy_result.key?('log')
+        save!
+      end
+    end
+
+    def target_count
+      targets&.size || 0
+    end
+
+    def formatted_targets
+      targets&.join(', ') || ''
+    end
+
+    private
+
+    def set_submitted_at
+      self.submitted_at ||= Time.current
+    end
+
+    def set_completed_at
+      self.completed_at ||= Time.current if completed?
+    end
+
+    def status_changed_to_completed?
+      status_changed? && completed?
+    end
+
+    def saved_result_and_log?
+      saved_change_to_result? || saved_change_to_log?
+    end
+
+    def cleanup_proxy_artifacts
+      return unless result.present? && log.present?
+      # Schedule cleanup of proxy artifacts if we have successfully saved the results
+      # ForemanTasks.async_task(::Actions::ForemanOpenbolt::CleanupProxyArtifacts,
+      #   smart_proxy_id,
+      #   job_id)
+      # Rails.logger.info("Scheduled cleanup for job #{job_id} on proxy #{smart_proxy_id}")
+    end
+  end
+end

data/app/views/foreman_openbolt/react_page.html.erb

@@ -0,0 +1 @@
+<div id="react-app-mount-point"></div>