katello 3.16.0.rc4 → 3.16.1

data/app/lib/actions/pulp3/capsule_content/refresh_content_guard.rb

@@ -0,0 +1,17 @@
+module Actions
+  module Pulp3
+    module CapsuleContent
+      class RefreshContentGuard < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy, options = {})
+          content_guard_api = ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
+          content_guard_href = content_guard_api.list&.results&.first&.pulp_href
+          if content_guard_href && options.try(:[], :update)
+            content_guard_api.partial_update content_guard_href
+          else
+            content_guard_api.create
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/capsule_content/sync.rb

@@ -11,7 +11,9 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.sync
+          sync_options = {}
+          sync_options[:optimize] = false if sync_options[:skip_metadata_check]
+          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.sync(sync_options)
         end
 
         def rescue_strategy_for_self

data/app/lib/actions/pulp3/content_migration.rb

@@ -12,6 +12,10 @@ module Actions
         migration_service = ::Katello::Pulp3::Migration.new(smart_proxy)
         migration_service.create_and_run_migrations
       end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Skip
+      end
     end
   end
 end

data/app/lib/actions/pulp3/orchestration/repository/copy_all_units.rb

@@ -16,13 +16,11 @@ module Actions
                   copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, source_repositories.first, smart_proxy, target_repo,
                                             filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                             rpm_filenames: rpm_filenames)
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
-                              repository_details: { latest_version_href: copy_action.output[:latest_version_href] }, tasks: copy_action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_action.output[:pulp_tasks])
                 else
                   #if we are not filtering, copy the version to the cv repository, and the units for each additional repo
                   action = plan_action(Actions::Pulp3::Repository::CopyVersion, source_repositories.first, smart_proxy, target_repo)
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
-                              repository_details: { latest_version_href: action.output[:latest_version_output] }, tasks: action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: action.output[:pulp_tasks])
                   copy_actions = []
                   #since we're creating a new version from the first repo, start copying at the 2nd
                   source_repositories[1..-1].each do |source_repo|

data/app/lib/actions/pulp3/orchestration/repository/multi_copy_all_units.rb

@@ -0,0 +1,36 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module Repository
+        class MultiCopyAllUnits < Pulp3::Abstract
+          def plan(extended_repo_map, smart_proxy, options = {})
+            solve_dependencies = options.fetch(:solve_dependencies, false)
+            if extended_repo_map.values.pluck(:filters).flatten.present? ||
+                extended_repo_map.keys.detect { |source_repos| source_repos.length > 1 }
+              sequence do
+                copy_action = plan_action(Actions::Pulp3::Repository::MultiCopyContent, extended_repo_map, smart_proxy,
+                                          solve_dependencies: solve_dependencies)
+                plan_action(Actions::Pulp3::Repository::SaveVersions, extended_repo_map.values.pluck(:dest_repo),
+                            tasks: copy_action.output[:pulp_tasks])
+              end
+            else
+              repo_id_map = {}
+              extended_repo_map.each do |source_repos, dest_repo_map|
+                repo_id_map[source_repos.first.id] = dest_repo_map[:dest_repo].id
+              end
+              plan_self(repo_id_map: repo_id_map)
+            end
+          end
+
+          def run
+            input[:repo_id_map].each do |source_repo_id, dest_repo_id|
+              dest_repo = ::Katello::Repository.find(dest_repo_id)
+              source_repo = ::Katello::Repository.find(source_repo_id)
+              dest_repo.update!(version_href: source_repo.version_href)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/repository/sync.rb

@@ -7,7 +7,9 @@ module Actions
           def plan(repository, smart_proxy, options)
             sequence do
               action_output = plan_action(Actions::Pulp3::Repository::Sync, repository, smart_proxy, options).output
-              version_output = plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
+
+              force_fetch_version = true if options[:optimize] == false
+              version_output = plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks], :force_fetch_version => force_fetch_version).output
               plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :contents_changed => version_output[:contents_changed])
               plan_self(:subaction_output => version_output)
             end

data/app/lib/actions/pulp3/orchestration/repository/trigger_update_repo_cert_guard.rb

@@ -0,0 +1,22 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module Repository
+        class TriggerUpdateRepoCertGuard < Pulp3::Abstract
+          def plan(repository, smart_proxy)
+            plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
+          end
+
+          def run
+            repository = ::Katello::Repository.find(input[:repository_id])
+            ForemanTasks.async_task(::Actions::Pulp3::Repository::UpdateCVRepositoryCertGuard, repository, smart_proxy)
+          end
+
+          def humanized_name
+            _("Updating repository authentication configuration")
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/copy_content.rb

@@ -11,7 +11,6 @@ module Actions
         def invoke_external_task
           source = ::Katello::Repository.find(input[:source_repository_id])
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
-          output[:latest_version_href] = target.backend_service(smart_proxy).read.latest_version_href
           output[:pulp_tasks] = target.backend_service(smart_proxy).copy_content_for_source(source, input)
         end
       end

data/app/lib/actions/pulp3/repository/multi_copy_content.rb

@@ -0,0 +1,28 @@
+module Actions
+  module Pulp3
+    module Repository
+      class MultiCopyContent < Pulp3::AbstractAsyncTask
+        def plan(extended_repo_map, smart_proxy, options)
+          repo_id_map = {}
+
+          extended_repo_map.each do |source_repos, dest_repo_map|
+            repo_id_map[source_repos&.map(&:id)] = { :dest_repo => dest_repo_map[:dest_repo].id,
+                                                     :filter_ids => dest_repo_map[:filters]&.map(&:id) }
+          end
+
+          plan_self(options.merge(:repo_id_map => repo_id_map, :smart_proxy_id => smart_proxy.id))
+        end
+
+        def invoke_external_task
+          repo_id_map = {}
+
+          input[:repo_id_map].each do |source_repo_ids, dest_repo_map|
+            repo_id_map[JSON.parse(source_repo_ids)] = dest_repo_map.deep_dup
+          end
+
+          output[:pulp_tasks] = ::Katello::Repository.find(repo_id_map.values.first[:dest_repo]).backend_service(smart_proxy).copy_content_from_mapping(repo_id_map, input)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/multi_copy_units.rb

@@ -0,0 +1,55 @@
+module Actions
+  module Pulp3
+    module Repository
+      class MultiCopyUnits < Pulp3::AbstractAsyncTask
+        # repo_map example: {
+        #   [<source_repo_ids>]: {
+        #     dest_repo: <dest_repo_id>,
+        #     base_version: <base_version>
+        #   }
+        # }
+        def plan(repo_map, unit_map, options = {})
+          if unit_map.values.flatten.any?
+            action_output = plan_self(repo_map: repo_map,
+                      unit_map: unit_map,
+                      dependency_solving: options[:dependency_solving],
+                      incremental_update: options[:incremental_update],
+                      smart_proxy_id: SmartProxy.pulp_master.id).output
+            plan_action(Pulp3::Repository::SaveVersions, repo_map.values.pluck(:dest_repo),
+                        tasks: action_output[:pulp_tasks]).output
+          end
+        end
+
+        def invoke_external_task
+          unit_hrefs = []
+          repo_map = {}
+
+          input[:repo_map].each do |source_repo_ids, dest_repo_map|
+            repo_map[JSON.parse(source_repo_ids)] = dest_repo_map
+          end
+
+          if input[:unit_map][:errata].any?
+            unit_hrefs << ::Katello::RepositoryErratum.
+              joins("inner join katello_errata on katello_repository_errata.erratum_id = katello_errata.id").
+              where("katello_repository_errata.repository_id in (#{repo_map.keys.join(',')}) and
+                    katello_errata.id in (#{input[:unit_map][:errata].join(",")})").map(&:erratum_pulp3_href)
+          end
+
+          if input[:unit_map][:rpms].any?
+            unit_hrefs << ::Katello::Rpm.where(:id => input[:unit_map][:rpms]).map(&:pulp_id)
+          end
+          unit_hrefs.flatten!
+
+          repo_map.each do |_source_repos, dest_repo_map|
+            dest_repo_map[:content_unit_hrefs] = unit_hrefs
+          end
+
+          target_repo = ::Katello::Repository.find(repo_map.values.first[:dest_repo])
+          unless unit_hrefs.flatten.empty?
+            output[:pulp_tasks] = target_repo.backend_service(SmartProxy.pulp_master).multi_copy_units(repo_map, input[:dependency_solving])
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/presenters/content_unit_presenter.rb

@@ -12,7 +12,7 @@ module Actions
           def humanized_details
             ret = []
             ret << _("Cancelled.") if cancelled?
-            ret << _("Total tasks: ") + ": #{finished_units}/#{total_units}"
+            ret << _("Total steps: ") + "#{finished_units}/#{total_units}"
             ret << "--------------------------------"
             progress_reports = sync_task.try(:[], 'progress_reports') || []
             progress_reports = progress_reports.sort_by { |pr| pr.try(:[], 'message') }

data/app/lib/actions/pulp3/repository/presenters/repair_presenter.rb

@@ -0,0 +1,85 @@
+module Actions
+  module Pulp3
+    module Repository
+      module Presenters
+        class RepairPresenter < Helpers::Presenter::Base
+          def humanized_output
+            if action.external_task
+              humanized_details
+            end
+          end
+
+          def progress
+            total_units == 0 ? 0.1 : finished_units.to_f / total_units
+          end
+
+          private
+
+          def repair_task
+            tasks = action.external_task.select do |task|
+              if task.key? 'name'
+                task['name'].include?("repair_version")
+              end
+            end
+            tasks.first
+          end
+
+          def cancelled?
+            repair_task && repair_task['state'] == 'cancelled'
+          end
+
+          def task_result
+            repair_task['result']
+          end
+
+          def task_result_details
+            task_result && task_result['details']
+          end
+
+          def humanized_details
+            ret = []
+            ret << _("Cancelled.") if cancelled?
+            ret << _("Total steps: ") + "#{finished_units}/#{total_units}"
+            ret << "--------------------------------"
+            progress_reports = repair_task.try(:[], 'progress_reports') || []
+            progress_reports = progress_reports.sort_by { |pr| pr.try(:[], 'message') }
+            progress_reports.each do |pr|
+              done = pr.try(:[], 'done')
+              total = pr.try(:[], 'total') || pr.try(:[], 'done')
+              unless done.nil? || total.nil?
+                ret << _(pr.try(:[], 'message') + ": #{done}/#{total}")
+              end
+            end
+
+            ret.join("\n")
+          end
+
+          def total_units
+            total_unit = 0
+            progress_reports = repair_task.try(:[], 'progress_reports') || []
+            progress_reports.each do |pr|
+              total = pr.try(:[], 'total')
+              total = pr.try(:[], 'done') if total.nil?
+              unless total.nil?
+                total_unit += total.to_i
+              end
+            end
+            total_unit
+          end
+
+          def finished_units
+            finished_unit = 0
+            progress_reports = repair_task.try(:[], 'progress_reports') || []
+            progress_reports.each do |pr|
+              done = pr.try(:[], 'done')
+              unless done.nil?
+                finished_unit += done.to_i
+              end
+            end
+            finished_unit
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/repair.rb

@@ -0,0 +1,29 @@
+module Actions
+  module Pulp3
+    module Repository
+      class Repair < Pulp3::AbstractAsyncTask
+        include Helpers::Presenter
+        def plan(repository_id, smart_proxy)
+          plan_self(:repository_id => repository_id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          output[:response] = repo.backend_service(smart_proxy).repair(repo.version_href)
+        end
+
+        def run_progress
+          presenter.progress
+        end
+
+        def run_progress_weight
+          10
+        end
+
+        def presenter
+          Presenters::RepairPresenter.new(self)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/save_version.rb

@@ -3,27 +3,39 @@ module Actions
     module Repository
       class SaveVersion < Pulp3::Abstract
         def plan(repository, options)
-          plan_self(:repository_id => repository.id, :tasks => options[:tasks], :repository_details => options[:repository_details])
+          fail "Cannot accept tasks and repository_details into Save Version." if options[:tasks].present? && options[:repository_details].present?
+          plan_self(:repository_id => repository.id, :tasks => options[:tasks], :repository_details => options[:repository_details], :force_fetch_version => options.fetch(:force_fetch_version, false))
         end
 
         def run
           repo = ::Katello::Repository.find(input[:repository_id])
 
-          if input[:tasks]
-            version_href = input[:tasks].last[:created_resources].first
-          end
-
-          if !version_href && input[:repository_details]
+          if input[:force_fetch_version]
+            version_href = fetch_version_href(repo)
+          elsif input[:repository_details].present?
             version_href = input[:repository_details][:latest_version_href]
+          elsif input[:tasks].present?
+            version_href = input[:tasks].last[:created_resources].first
+          else
+            version_href = fetch_version_href(repo)
           end
 
           if version_href
-            repo.update(:version_href => version_href)
-            output[:contents_changed] = true
+            if repo.version_href != version_href || input[:force_fetch_version]
+              output[:contents_changed] = true
+              repo.update(:version_href => version_href)
+            end
           else
             output[:contents_changed] = false
           end
         end
+
+        def fetch_version_href(repo)
+          # Fetch latest Pulp 3 repo version
+          repo_backend_service = repo.backend_service(SmartProxy.pulp_master)
+          repo_href = repo_backend_service.repository_reference.repository_href
+          repo_backend_service.api.repositories_api.read(repo_href).latest_version_href
+        end
       end
     end
   end

data/app/lib/actions/pulp3/repository/save_versions.rb

@@ -0,0 +1,73 @@
+module Actions
+  module Pulp3
+    module Repository
+      class SaveVersions < Pulp3::Abstract
+        def plan(repository_ids, options)
+          plan_self(:repository_ids => repository_ids, :tasks => options[:tasks])
+        end
+
+        def run
+          return if input[:tasks].empty?
+          version_hrefs = input[:tasks].last[:created_resources]
+          repositories = find_repositories(input[:repository_ids])
+
+          output.merge!(contents_changed: false, updated_repositories: [])
+          repositories.each do |repo|
+            repo_backend_service = repo.backend_service(SmartProxy.pulp_master)
+            if repo.version_href
+              # Chop off the version number to compare base repo strings
+              unversioned_href = repo.version_href[0..-2].rpartition('/').first
+              # Could have multiple version_hrefs for the same repo depending on the copy task
+              new_version_hrefs = version_hrefs.collect do |version_href|
+                version_href if unversioned_href == version_href[0..-2].rpartition('/').first
+              end
+
+              new_version_hrefs.compact!
+              if new_version_hrefs.size > 1
+                # Find latest version_href by its version number
+                new_version_href = version_map(new_version_hrefs).max_by { |_href, version| version }.first
+              else
+                new_version_href = new_version_hrefs.first
+              end
+
+              # Successive incremental updates won't generate a new repo version, so fetch the latest Pulp 3 repo version
+              new_version_href ||= latest_version_href(repo_backend_service)
+            else
+              new_version_href = latest_version_href(repo_backend_service)
+            end
+
+            unless new_version_href == repo.version_href
+              repo.update(version_href: new_version_href)
+              repo.index_content
+              output[:contents_changed] = true
+              output[:updated_repositories] << repo.id
+            end
+          end
+        end
+
+        def version_map(version_hrefs)
+          version_map = {}
+          version_hrefs.each do |href|
+            version_map[href] = href.split("/")[-1].to_i
+          end
+          version_map
+        end
+
+        def latest_version_href(repo_backend_service)
+          repo_backend_service.api.repositories_api.
+            read(repo_backend_service.repository_reference.repository_href).latest_version_href
+        end
+
+        def find_repositories(repository_ids)
+          repository_ids.collect do |repo_id|
+            if repo_id.is_a?(Hash)
+              ::Katello::Repository.find(repo_id.with_indifferent_access[:id])
+            else
+              ::Katello::Repository.find(repo_id)
+            end
+          end
+        end
+      end
+    end
+  end
+end