foreman_rh_cloud 13.0.8 → 13.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aba47c451526fd85b565ba8fdcb17d6b7d643cd3c6fbea186a40943a6a4887bc
-  data.tar.gz: 16357a50048143a026497016cd38533b34d211c6ea61fccf55bd2a298852766e
+  metadata.gz: ae4a5664771227e232b4a38812dbf04fe704f1be85f10105873543cb2cc4b1c2
+  data.tar.gz: 69720759a2e2365af0b9c7e94c82e0f3adb15202d65ddf454e7beefa694cb30d
 SHA512:
-  metadata.gz: c863fed43a17edb0cfdb465e4b26b529e9a09460ab9677cea6e94bc3fea6c560c8fdf01c691ea4ea2d495c7ab715db90cbee5c3bf87217e3aae135c9b29b5e2f
-  data.tar.gz: c1d61f3f092e87829a28fd1ac237f46c29772aeae926d2a3c65cba440d3233844aa8dd40eb38a18ff56a09c68f9578aaf83a142d37d1aff06679d0ba6b87c904
+  metadata.gz: f8c2edc1f86b1db29db4f8209d26fb3466795d1f31b7854cfd7dc826ae35f29b7557dc7388ebf0ab2a4217c9ae4399f765e75afe1c7278676ab6a25e28091d3b
+  data.tar.gz: 725d9f97783c10cbe2d69345ce8647c94f5fbf12d1cffd5e087f7a5cacc528423c253047ae3e97e0b3af307db1e995ee660848bbe839d44d989f4d5d746d5085

data/app/controllers/concerns/inventory_upload/report_actions.rb

@@ -11,7 +11,14 @@ module InventoryUpload
     end
 
     def start_report_generation(organization_id, disconnected)
-      ForemanTasks.async_task(ForemanInventoryUpload::Async::GenerateReportJob, ForemanInventoryUpload.generated_reports_folder, organization_id, disconnected)
+      upload = !disconnected
+      ForemanTasks.async_task(
+        ForemanInventoryUpload::Async::HostInventoryReportJob,
+        ForemanInventoryUpload.generated_reports_folder,
+        organization_id,
+        "", # hosts_filter
+        upload
+      )
     end
 
     def report_file(organization_id)

data/app/controllers/foreman_inventory_upload/accounts_controller.rb

@@ -6,15 +6,20 @@ module ForemanInventoryUpload
 
       accounts = Hash[
         labels.map do |id, label|
-          generate_report_status = status_for(id, ForemanInventoryUpload::Async::GenerateReportJob)
-          upload_report_status = status_for(id, ForemanInventoryUpload::Async::UploadReportJob)
+          generate_task = latest_task_for(id, ForemanInventoryUpload::Async::HostInventoryReportJob)
+
+          # Check sub-action completion status
+          generated_status = sub_action_status(generate_task, 'GenerateHostReport')
+          uploaded_status = sub_action_status(generate_task, 'UploadReportDirectJob')
+
           report_file_paths = ForemanInventoryUpload.report_file_paths(id)
 
           [
             label,
             {
-              generate_report_status: generate_report_status,
-              upload_report_status: upload_report_status,
+              generated_status: generated_status,
+              uploaded_status: uploaded_status,
+              generate_task: task_json(generate_task),
               report_file_paths: report_file_paths,
               id: id,
             },
@@ -30,9 +35,79 @@ module ForemanInventoryUpload
 
     private
 
-    def status_for(label, job_class)
-      label = job_class.output_label(label)
-      ForemanInventoryUpload::Async::ProgressOutput.get(label)&.status
+    def controller_permission
+      'foreman_rh_cloud'
+    end
+
+    def latest_task_for(org_id, job_class)
+      ForemanTasks::Task
+        .for_action_types([job_class.name])
+        .joins(:links)
+        .where(foreman_tasks_links: {
+          resource_type: 'Organization',
+          resource_id: org_id,
+        })
+        .with_duration
+        .order('started_at DESC')
+        .first
+    end
+
+    def sub_action_status(task, action_class_name)
+      return nil unless task
+
+      # If task is still running, return the state
+      return task.state unless task.state == 'stopped'
+
+      # For GenerateHostReport: always show status if task completed (generation always runs)
+      if action_class_name == 'GenerateHostReport'
+        return task.result
+      end
+
+      # For UploadReportDirectJob: only show status if task had upload enabled
+      if action_class_name == 'UploadReportDirectJob'
+        main_action = task.main_action
+        return nil unless main_action.respond_to?(:input)
+
+        # Check if upload was enabled for this task
+        return nil unless main_action.input[:upload]
+
+        # Return the task result
+        return task.result
+      end
+
+      nil
+    rescue StandardError => e
+      Rails.logger.warn("Failed to get sub-action status for #{action_class_name} in task #{task.id}: #{e.message}")
+      nil
+    end
+
+    def task_json(task)
+      return nil unless task
+
+      {
+        id: task.id,
+        label: task.label,
+        state: task.state,
+        result: task.result,
+        progress: task.progress,
+        started_at: task.started_at,
+        ended_at: task.ended_at,
+        duration: task.try(:duration)&.to_f,
+        report_file_path: task_report_file_path(task),
+      }
+    end
+
+    def task_report_file_path(task)
+      return nil unless task&.state == 'stopped'
+
+      # Get the main action from the task
+      main_action = task.main_action
+      return nil unless main_action.respond_to?(:report_file_path)
+
+      main_action.report_file_path
+    rescue StandardError => e
+      Rails.logger.warn("Failed to get report file path for task #{task.id}: #{e.message}")
+      nil
     end
   end
 end

data/app/controllers/foreman_inventory_upload/api/tasks_controller.rb

@@ -0,0 +1,110 @@
+module ForemanInventoryUpload
+  module Api
+    class TasksController < ::Api::V2::BaseController
+      ACTION_TYPES = [
+        'ForemanInventoryUpload::Async::HostInventoryReportJob',
+        'ForemanInventoryUpload::Async::UploadReportDirectJob',
+      ].freeze
+
+      # GET /foreman_inventory_upload/api/tasks/current
+      # Returns current running/active tasks for inventory operations
+      def current
+        organization_id = validate_organization_id if params[:organization_id].present?
+        return if performed?
+
+        tasks = ForemanTasks::Task
+                .active
+                .for_action_types(ACTION_TYPES)
+                .with_duration
+
+        if organization_id.present?
+          tasks = tasks.joins(:links)
+                       .where(foreman_tasks_links: {
+                         resource_type: 'Organization',
+                         resource_id: organization_id,
+                       })
+        end
+
+        render json: {
+          tasks: tasks.map { |task| task_json(task) },
+        }
+      end
+
+      # GET /foreman_inventory_upload/api/tasks/history
+      # Returns recent task history for inventory operations
+      def history
+        organization_id = validate_organization_id if params[:organization_id].present?
+        return if performed?
+
+        limit = validated_limit
+
+        tasks = ForemanTasks::Task
+                .for_action_types(ACTION_TYPES)
+                .with_duration
+                .order('started_at DESC')
+                .limit(limit)
+
+        if organization_id.present?
+          tasks = tasks.joins(:links)
+                       .where(foreman_tasks_links: {
+                         resource_type: 'Organization',
+                         resource_id: organization_id,
+                       })
+        end
+
+        render json: {
+          tasks: tasks.map { |task| task_json(task) },
+        }
+      end
+
+      private
+
+      def controller_permission
+        'foreman_rh_cloud'
+      end
+
+      def task_json(task)
+        {
+          id: task.id,
+          label: task.label,
+          action: task.action,
+          state: task.state,
+          result: task.result,
+          progress: task.progress,
+          started_at: task.started_at,
+          ended_at: task.ended_at,
+          duration: task.duration&.to_f,
+          humanized: task.humanized,
+          report_file_path: task_report_file_path(task),
+        }
+      end
+
+      def task_report_file_path(task)
+        return nil unless task.state == 'stopped' && task.result == 'success'
+        return nil unless task.action == 'ForemanInventoryUpload::Async::HostInventoryReportJob'
+
+        task.main_action&.output&.[]('report_file')
+      end
+
+      def validate_organization_id
+        org_id = params[:organization_id].to_i
+        if org_id.zero?
+          render json: { message: 'Invalid organization_id parameter' }, status: :bad_request
+          return nil
+        end
+
+        begin
+          Organization.find(org_id).id
+        rescue ActiveRecord::RecordNotFound
+          render json: { message: "Organization with id #{org_id} not found" }, status: :not_found
+          nil
+        end
+      end
+
+      def validated_limit
+        limit = params[:limit]&.to_i || 10
+        limit.clamp(1, 100)
+      end
+    end
+  end
+end

data/app/controllers/foreman_inventory_upload/reports_controller.rb

@@ -4,30 +4,54 @@ module ForemanInventoryUpload
   class ReportsController < ::ApplicationController
     include InventoryUpload::ReportActions
 
-    def last
-      label = ForemanInventoryUpload::Async::GenerateReportJob.output_label(params[:organization_id])
-      output = ForemanInventoryUpload::Async::ProgressOutput.get(label)&.full_output
-      task_label = ForemanInventoryUpload::Async::GenerateAllReportsJob.name
-      scheduled = ForemanTasks::Task.where(
-        :label => task_label,
-        :state => 'scheduled'
-      ).first&.start_at || nil
+    def generate
+      organization_id = validate_organization_id
+      return if performed?
+
+      disconnected = boolean_param(:disconnected)
+
+      task = start_report_generation(organization_id, disconnected)
 
       render json: {
-        output: output,
-        scheduled: scheduled,
+        id: task.id,
+        humanized: {
+          action: task.action,
+        },
       }, status: :ok
     end
 
-    def generate
-      organization_id = params[:organization_id]
-      disconnected = params[:disconnected]
+    private
 
-      start_report_generation(organization_id, disconnected)
+    def controller_permission
+      'foreman_rh_cloud'
+    end
 
-      render json: {
-        action_status: 'success',
-      }, status: :ok
+    def action_permission
+      case params[:action]
+      when 'generate'
+        'generate'
+      else
+        super
+      end
+    end
+
+    def validate_organization_id
+      org_id = params[:organization_id].to_i
+      if org_id.zero?
+        render json: { message: 'Invalid organization_id parameter' }, status: :bad_request
+        return nil
+      end
+
+      begin
+        Organization.find(org_id).id
+      rescue ActiveRecord::RecordNotFound
+        render json: { message: "Organization with id #{org_id} not found" }, status: :not_found
+        nil
+      end
+    end
+
+    def boolean_param(key)
+      Foreman::Cast.to_bool(params[key]) || false
     end
   end
 end

data/app/controllers/foreman_inventory_upload/uploads_controller.rb

@@ -5,15 +5,6 @@ module ForemanInventoryUpload
 
     before_action :require_non_iop_smart_proxy, only: [:enable_cloud_connector]
 
-    def last
-      label = ForemanInventoryUpload::Async::UploadReportJob.output_label(params[:organization_id])
-      output = ForemanInventoryUpload::Async::ProgressOutput.get(label)&.full_output
-
-      render json: {
-        output: output,
-      }, status: :ok
-    end
-
     def download_file
       filename, file = report_file(params[:organization_id])
 

data/config/routes.rb

@@ -1,8 +1,6 @@
 Rails.application.routes.draw do
   namespace :foreman_inventory_upload do
-    get ':organization_id/reports/last', to: 'reports#last', constraints: { organization_id: %r{[^\/]+} }
     post ':organization_id/reports', to: 'reports#generate', constraints: { organization_id: %r{[^\/]+} }
-    get ':organization_id/uploads/last', to: 'uploads#last', constraints: { organization_id: %r{[^\/]+} }
     get ':organization_id/uploads/file', to: 'uploads#download_file', constraints: { organization_id: %r{[^\/]+} }
     get 'missing_hosts', to: 'missing_hosts#index'
     get 'accounts', to: 'accounts#index'
@@ -76,6 +74,10 @@ Rails.application.routes.draw do
         post 'enable_connector', to: 'inventory#enable_cloud_connector'
         post 'cloud_request', to: 'cloud_request#update'
         get 'advisor_engine_config', to: 'advisor_engine_config#show'
+
+        # Inventory upload task endpoints
+        get 'inventory_upload/tasks/current', to: 'foreman_inventory_upload/api/tasks#current'
+        get 'inventory_upload/tasks/history', to: 'foreman_inventory_upload/api/tasks#history'
       end
 
       namespace 'advisor_engine' do

data/db/migrate/20251209163012_drop_task_output_tables.foreman_rh_cloud.rb

@@ -0,0 +1,24 @@
+class DropTaskOutputTables < ActiveRecord::Migration[6.0]
+  def up
+    drop_table :task_output_lines
+    drop_table :task_output_statuses
+  end
+
+  def down
+    create_table :task_output_lines do |t|
+      t.string :label
+      t.string :line
+      t.timestamps
+
+      t.index :label
+    end
+
+    create_table :task_output_statuses do |t|
+      t.string :label
+      t.string :status
+      t.timestamps
+
+      t.index :label, unique: true
+    end
+  end
+end

data/lib/foreman_inventory_upload/async/generate_all_reports_job.rb

@@ -42,7 +42,7 @@ module ForemanInventoryUpload
       end
 
       def plan_generate_report(folder, organization, disconnected)
-        plan_action(ForemanInventoryUpload::Async::GenerateReportJob, folder, organization.id, disconnected)
+        plan_action(ForemanInventoryUpload::Async::HostInventoryReportJob, folder, organization.id, '', !disconnected)
       end
 
       def logger

data/lib/foreman_inventory_upload/async/host_inventory_report_job.rb

@@ -1,7 +1,21 @@
 module ForemanInventoryUpload
   module Async
     class HostInventoryReportJob < ::Actions::EntryAction
+      def resource_locks
+        :link
+      end
+
       def plan(base_folder, organization_id, hosts_filter = "", upload = true)
+        organization = Organization.find(organization_id)
+        action_subject(organization)
+
+        plan_self(
+          base_folder: base_folder,
+          organization_id: organization_id,
+          hosts_filter: hosts_filter,
+          upload: upload
+        )
+
         sequence do
           plan_action(
             GenerateHostReport,
@@ -31,9 +45,34 @@ module ForemanInventoryUpload
         _("Host inventory report job")
       end
 
+      def organization
+        Organization.find(input[:organization_id])
+      end
+
       def organization_id
         input[:organization_id]
       end
+
+      def report_file_path
+        filename = ForemanInventoryUpload.facts_archive_name(input[:organization_id], input[:hosts_filter])
+
+        if input[:upload]
+          # For upload tasks, check: done folder (uploaded), uploads folder (queued), generated_reports folder (failed upload)
+          [
+            ForemanInventoryUpload.done_file_path(filename),
+            ForemanInventoryUpload.uploads_file_path(filename),
+            File.join(input[:base_folder], filename),
+          ].find { |path| File.exist?(path) }
+        else
+          # For generate-only tasks, only check generated_reports folder
+          generated_path = File.join(input[:base_folder], filename)
+          File.exist?(generated_path) ? generated_path : nil
+        end
+      end
+
+      def rescue_strategy_for_self
+        Dynflow::Action::Rescue::Fail
+      end
     end
   end
 end

data/lib/foreman_inventory_upload/async/queue_for_upload_job.rb

@@ -9,7 +9,6 @@ module ForemanInventoryUpload
       def run
         logger.debug('Ensuring objects')
         ensure_ouput_folder
-        ensure_output_script
         logger.debug("Copying #{report_file} to #{uploads_folder}")
         enqueued_file_name = File.join(uploads_folder, report_file)
         FileUtils.mv(File.join(base_folder, report_file), enqueued_file_name)
@@ -22,31 +21,10 @@ module ForemanInventoryUpload
         @uploads_folder ||= ForemanInventoryUpload.uploads_folder
       end
 
-      def script_file
-        @script_file ||= File.join(uploads_folder, ForemanInventoryUpload.upload_script_file)
-      end
-
       def ensure_ouput_folder
         FileUtils.mkdir_p(uploads_folder)
       end
 
-      def ensure_output_script
-        return if File.exist?(script_file)
-
-        script_source = File.join(ForemanRhCloud::Engine.root, 'lib/foreman_inventory_upload/scripts/uploader.sh.erb')
-
-        template_src = Foreman::Renderer::Source::String.new(content: File.read(script_source))
-        scope = Foreman::Renderer::Scope::Base.new(
-          source: template_src,
-          variables: {
-            upload_url: ForemanInventoryUpload.upload_url,
-          }
-        )
-        script_source = Foreman::Renderer.render(template_src, scope)
-        File.write(script_file, script_source)
-        FileUtils.chmod('+x', script_file)
-      end
-
       def logger
         Foreman::Logging.logger('background')
       end
@@ -60,7 +38,7 @@ module ForemanInventoryUpload
       end
 
       def plan_upload_report(enqueued_file_name, organization_id)
-        plan_action(UploadReportJob, enqueued_file_name, organization_id)
+        plan_action(UploadReportDirectJob, enqueued_file_name, organization_id)
       end
     end
   end

data/lib/foreman_inventory_upload/async/upload_report_direct_job.rb

@@ -0,0 +1,171 @@
+require 'tempfile'
+require 'rest-client'
+
+module ForemanInventoryUpload
+  module Async
+    class UploadReportDirectJob < ::Actions::EntryAction
+      include AsyncHelpers
+      include ::ForemanRhCloud::Async::ExponentialBackoff
+      include ::ForemanRhCloud::CloudRequest
+
+      # Wrapper class to avoid monkey-patching File for multipart uploads
+      class FileUpload
+        attr_reader :file, :content_type
+
+        def initialize(file, content_type:)
+          @file = file
+          @content_type = content_type
+        end
+
+        def read(*args)
+          @file.read(*args)
+        end
+
+        def path
+          @file.path
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @file.respond_to?(method_name, include_private) || super
+        end
+
+        def method_missing(method_name, *args, &block)
+          if @file.respond_to?(method_name)
+            @file.send(method_name, *args, &block)
+          else
+            super
+          end
+        end
+      end
+
+      def self.output_label(label)
+        "upload_for_#{label}"
+      end
+
+      def resource_locks
+        :link
+      end
+
+      def plan(filename, organization_id)
+        organization = Organization.find(organization_id)
+        action_subject(organization)
+
+        plan_self(
+          filename: filename,
+          organization_id: organization_id
+        )
+      end
+
+      def try_execute
+        if content_disconnected?
+          logger.info("Upload canceled: connection to Insights is not enabled. Report location: #{filename}")
+          return
+        end
+
+        unless organization.owner_details&.dig('upstreamConsumer', 'idCert')
+          logger.info("Skipping organization '#{organization}', no candlepin certificate defined.")
+          return
+        end
+
+        Tempfile.create([organization.name, '.pem']) do |cer_file|
+          cer_file.write(certificate[:cert])
+          cer_file.write(certificate[:key])
+          cer_file.flush
+          upload_file(cer_file.path)
+        end
+
+        move_to_done_folder
+        done!
+      end
+
+      def upload_file(cer_path)
+        cert_content = File.read(cer_path)
+
+        File.open(filename, 'rb') do |file|
+          # Wrap file with FileUpload class for RestClient multipart handling
+          # RestClient requires objects with :read, :path, and :content_type methods
+          wrapped_file = FileUpload.new(file, content_type: 'application/vnd.redhat.qpc.tar+tgz')
+
+          response = execute_cloud_request(
+            method: :post,
+            url: ForemanInventoryUpload.upload_url,
+            payload: {
+              multipart: true,
+              file: wrapped_file,
+            },
+            headers: {
+              'X-Org-Id' => organization.label,
+            },
+            ssl_client_cert: OpenSSL::X509::Certificate.new(cert_content),
+            ssl_client_key: OpenSSL::PKey::RSA.new(cert_content),
+            timeout: 600,
+            open_timeout: 60
+          )
+
+          logger.debug("Upload response code: #{response.code}")
+        end
+      end
+
+      def move_to_done_folder
+        FileUtils.mkdir_p(ForemanInventoryUpload.done_folder)
+        done_file = ForemanInventoryUpload.done_file_path(File.basename(filename))
+        if File.exist?(done_file)
+          logger.warn("Destination file #{done_file} already exists. Overwriting with new report.")
+        end
+        FileUtils.mv(filename, done_file, force: true)
+        logger.debug("Moved #{filename} to #{done_file}")
+      end
+
+      def certificate
+        ForemanRhCloud.with_iop_smart_proxy? ? foreman_certificate : manifest_certificate
+      end
+
+      def manifest_certificate
+        candlepin_id_certificate = organization.owner_details['upstreamConsumer']['idCert']
+        {
+          cert: candlepin_id_certificate['cert'],
+          key: candlepin_id_certificate['key'],
+        }
+      end
+
+      def foreman_certificate
+        cert_path = Setting[:ssl_certificate]
+        key_path = Setting[:ssl_priv_key]
+
+        unless cert_path && File.readable?(cert_path)
+          raise "SSL certificate file not found or not readable: #{cert_path}"
+        end
+
+        unless key_path && File.readable?(key_path)
+          raise "SSL private key file not found or not readable: #{key_path}"
+        end
+
+        {
+          cert: File.read(cert_path),
+          key: File.read(key_path),
+        }
+      end
+
+      def filename
+        input[:filename]
+      end
+
+      def organization
+        Organization.find(input[:organization_id])
+      end
+
+      def content_disconnected?
+        return false if ForemanRhCloud.with_iop_smart_proxy?
+        !Setting[:subscription_connection_enabled]
+      end
+
+      def logger
+        Foreman::Logging.logger('background')
+      end
+
+      def rescue_strategy_for_self
+        Dynflow::Action::Rescue::Fail
+      end
+    end
+  end
+end

data/lib/foreman_inventory_upload.rb

@@ -48,10 +48,6 @@ module ForemanInventoryUpload
     @outputs_folder ||= ensure_folder(File.join(ForemanInventoryUpload.base_folder, 'outputs/'))
   end
 
-  def self.upload_script_file
-    'uploader.sh'
-  end
-
   def self.facts_archive_name(organization, filter = nil)
     "report_for_#{organization}#{filter.empty? ? nil : "[#{filter.to_s.parameterize}]"}.tar.xz"
   end

data/lib/foreman_rh_cloud/plugin.rb

@@ -44,6 +44,7 @@ module ForemanRhCloud
             'foreman_inventory_upload/reports': [:last],
             'foreman_inventory_upload/uploads': [:auto_upload, :show_auto_upload, :download_file, :last],
             'foreman_inventory_upload/tasks': [:show],
+            'foreman_inventory_upload/api/tasks': [:current, :history],
             'foreman_inventory_upload/cloud_status': [:index],
             'foreman_inventory_upload/uploads_settings': [:index],
             'foreman_inventory_upload/missing_hosts': [:index],