katello 3.16.0.rc5.1 → 3.16.2

data/app/lib/actions/katello/repository/verify_checksum.rb

@@ -0,0 +1,28 @@
+module Actions
+  module Katello
+    module Repository
+      class VerifyChecksum < Actions::EntryAction
+        include Helpers::Presenter
+        include Actions::Katello::PulpSelector
+
+        def plan(repo)
+          action_subject(repo)
+
+          if SmartProxy.pulp_master.pulp3_support?(repo)
+            plan_action(Actions::Pulp3::Repository::Repair, repo.id, SmartProxy.pulp_master)
+          else
+            options = {}
+            options[:validate_contents] = true
+            plan_action(Actions::Katello::Repository::Sync, repo, nil, options)
+          end
+        end
+
+        def presenter
+          found = all_planned_actions(Katello::Repository::Sync)
+          found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?
+          Helpers::Presenter::Delegated.new(self, found)
+        end
+      end
+    end
+  end
+end

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

@@ -4,8 +4,9 @@ module Actions
       module Repository
         class Sync < Pulp::Abstract
           include Actions::Helpers::OutputPropagator
-          def plan(_repository, _smart_proxy, options)
+          def plan(repository, smart_proxy, options)
             sequence do
+              options.merge!(:repo_id => repository.id, :smart_proxy_id => smart_proxy.id)
               action_output = plan_action(Actions::Pulp::Repository::Sync, options).output
               plan_self(:subaction_output => action_output)
             end

data/app/lib/actions/pulp/repository/sync.rb

@@ -14,8 +14,9 @@ module Actions
           overrides = {}
           overrides[:feed] = input[:source_url] if input[:source_url]
           overrides[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
-          overrides[:options] = input[:options] if input[:options]
+          overrides.merge(input[:options]) if input[:options]
           repo = ::Katello::Repository.find(input[:repo_id])
+
           output[:pulp_tasks] = repo.backend_service(::SmartProxy.pulp_master).sync(overrides)
         end
 

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

@@ -4,41 +4,6 @@ module Actions
       include Actions::Base::Polling
       include ::Dynflow::Action::Cancellable
 
-      WAITING = ['waiting',
-                 SKIPPED = 'skipped'.freeze,
-                 RUNNING = 'running'.freeze,
-                 COMPLETED = 'completed'.freeze,
-                 FAILED = 'failed'.freeze,
-                 CANCELED = 'canceled'.freeze].freeze
-
-      FINISHED_STATES = [COMPLETED, FAILED, CANCELED, SKIPPED].freeze
-
-      # A call report Looks like:  {"task":"/pulp/api/v3/tasks/5/"}
-      # {
-      #    "pulp_href":"/pulp/api/v3/tasks/4/",
-      #    "pulp_created":"2019-02-21T19:50:40.476767Z",
-      #    "job_id":"d0359658-d926-47a2-b430-1b2092b3bd86",
-      #    "state":"completed",
-      #    "name":"pulp_file.app.tasks.publishing.publish",
-      #    "started_at":"2019-02-21T19:50:40.556002Z",
-      #    "finished_at":"2019-02-21T19:50:40.618397Z",
-      #    "non_fatal_errors":[
-      #
-      #    ],
-      #    "error":null,
-      #    "worker":"/pulp/api/v3/workers/1/",
-      #    "parent":null,
-      #    "spawned_tasks":[
-      #
-      #    ],
-      #    "progress_reports":[
-      #
-      #    ],
-      #    "created_resources":[
-      #       "/pulp/api/v3/publications/1/"
-      #    ]
-      # }
-
       def run(event = nil)
         # do nothing when the action is being skipped
         unless event == Dynflow::Action::Skip
@@ -49,16 +14,16 @@ module Actions
       def humanized_state
         case state
         when :running
-          if self.external_task.nil?
+          if self.combined_tasks.empty?
             _("initiating Pulp task")
           else
             _("checking Pulp task status")
           end
         when :suspended
-          if external_task&.all? { |task| task[:start_time].nil? }
-            _("waiting for Pulp to start the task")
-          else
+          if combined_tasks.any?(&:started?)
             _("waiting for Pulp to finish the task")
+          else
+            _("waiting for Pulp to start the task")
           end
         else
           super
@@ -66,28 +31,50 @@ module Actions
       end
 
       def done?
-        external_task&.all? { |task| task[:finish_time] || FINISHED_STATES.include?(task[:state]) }
+        combined_tasks&.all? { |task| task.done? }
       end
 
       def external_task
-        output[:pulp_tasks]
+        #this must return nil until external_task= is called
+        combined_tasks
+      end
+
+      def combined_tasks
+        return nil if pulp_tasks.nil? || task_groups.nil?
+        pulp_tasks + task_groups
+      end
+
+      def pulp_tasks
+        return nil if output[:pulp_tasks].nil?
+        output[:pulp_tasks] = new_or_existing_objects(::Katello::Pulp3::Task, output[:pulp_tasks])
+      end
+
+      def task_groups
+        return nil if output[:task_groups].nil?
+        output[:task_groups] = new_or_existing_objects(::Katello::Pulp3::TaskGroup, output[:task_groups])
+      end
+
+      def new_or_existing_objects(object_class, objects)
+        objects.map do |object|
+          if object.is_a?(object_class)
+            object
+          else
+            object_class.new(smart_proxy, object)
+          end
+        end
       end
 
       def cancel!
         cancel
-        self.external_task = poll_external_task
+        poll_external_task
         # We suspend the action and the polling will take care of finding
         # out if the cancelling was successful
         suspend unless done?
       end
 
       def cancel
-        output[:pulp_tasks].each do |pulp_task|
-          data = PulpcoreClient::Task.new(state: 'canceled')
-          tasks_api.tasks_cancel(pulp_task['pulp_href'], data)
-          #the main task may have completed, so cancel spawned tasks too
-          pulp_task['spawned_tasks']&.each { |spawned| tasks_api.tasks_cancel(spawned['pulp_href'], data) }
-        end
+        pulp_tasks.each { |task| task.cancel }
+        task_groups.each { |task_group| task_group.cancel }
       end
 
       def rescue_external_task(error)
@@ -109,24 +96,42 @@ module Actions
         response
       end
 
+      def check_for_errors
+        combined_tasks.each do |task|
+          if (message = task.error)
+            fail ::Katello::Errors::Pulp3Error, message
+          end
+        end
+      end
+
       def external_task=(external_task_data)
-        output[:pulp_tasks] = transform_task_response(external_task_data)
-        output[:pulp_tasks].each do |pulp_task|
-          if (pulp_exception = ::Katello::Errors::Pulp3Error.from_task(pulp_task))
-            fail pulp_exception
+        #currently we assume everything coming from invoke_external_task_methods are tasks
+        tasks = transform_task_response(external_task_data)
+        output[:pulp_tasks] = new_or_existing_objects(::Katello::Pulp3::Task, tasks)
+
+        add_task_groups
+        check_for_errors
+      end
+
+      def add_task_groups
+        output[:task_groups] ||= []
+        pulp_tasks.each do |task|
+          if task.task_group_href && !tracking_task_group?(task.task_group_href)
+            output[:task_groups] << ::Katello::Pulp3::TaskGroup.new_from_href(smart_proxy, task.task_group_href)
           end
         end
       end
 
-      def tasks_api
-        ::Katello::Pulp3::Api::Core.new(smart_proxy).tasks_api
+      def tracking_task_group?(href)
+        task_groups&.any? { |group| group.href == href }
       end
 
       def poll_external_task
-        external_task.map do |task|
-          task = tasks_api.read(task['pulp_href'] || task['task'])
-          task.as_json
-        end
+        pulp_tasks.each(&:poll)
+        output[:task_groups] = task_groups.each(&:poll) if task_groups
+        add_task_groups
+        check_for_errors
+        pulp_tasks
       end
     end
   end

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/content_view/delete_repository_references.rb

@@ -14,7 +14,7 @@ module Actions
           content_view.repository_references.each do |repository_reference|
             repo = repository_reference.root_repository.library_instance
             #force pulp3 in case we've done migrations, but haven't switched over yet
-            tasks << repo.backend_service(smart_proxy, true).delete(repository_reference.repository_href)
+            tasks << repo.backend_service(smart_proxy, true).delete_repository(repository_reference)
           end
           content_view.repository_references.destroy_all
 

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/delete.rb

@@ -8,7 +8,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).delete
+          output[:response] = repo.backend_service(smart_proxy).delete_repository
         end
       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

@@ -3,7 +3,7 @@ module Actions
     module Repository
       class MultiCopyUnits < Pulp3::AbstractAsyncTask
         # repo_map example: {
-        #   <source_repo_id>: {
+        #   [<source_repo_ids>]: {
         #     dest_repo: <dest_repo_id>,
         #     base_version: <base_version>
         #   }
@@ -22,7 +22,11 @@ module Actions
 
         def invoke_external_task
           unit_hrefs = []
-          repo_map = input[:repo_map]
+          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.
@@ -34,13 +38,16 @@ module Actions
           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
 
-          # TODO: Fix this workaround by refactoring copy_units after general content view dep solving is refactored
-          source_repo = ::Katello::Repository.find(repo_map.keys.first)
           target_repo = ::Katello::Repository.find(repo_map.values.first[:dest_repo])
-          dest_base_version = repo_map.values.first[:base_version]
-          repo_map.delete(repo_map.keys.first)
-          output[:pulp_tasks] = target_repo.backend_service(SmartProxy.pulp_master).copy_units(source_repo, unit_hrefs.flatten, input[:dependency_solving], dest_base_version, repo_map)
+          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