katello 3.17.0.rc1 → 3.17.0.rc2

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

@@ -1,10 +1,10 @@
 module Actions
   module Pulp3
     class ContentMigration < Pulp3::AbstractAsyncTask
-      def plan(smart_proxy = SmartProxy.pulp_master)
+      def plan(smart_proxy, options)
         sequence do
-          plan_self(smart_proxy_id: smart_proxy.id)
-          plan_action(Actions::Pulp3::ImportMigration)
+          action = plan_self(smart_proxy_id: smart_proxy.id)
+          plan_action(Actions::Pulp3::ImportMigration, options.merge(:dependency => action.output))
         end
       end
 

data/app/lib/actions/pulp3/content_view_version/create_exporter.rb

@@ -0,0 +1,20 @@
+module Actions
+  module Pulp3
+    module ContentViewVersion
+      class CreateExporter < Pulp3::Abstract
+        input_format do
+          param :smart_proxy_id, Integer
+          param :content_view_version_id, Integer
+          param :destination_server, String
+        end
+
+        def run
+          cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          output[:exporter_data] = ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
+                                                                            content_view_version: cvv,
+                                                                            destination_server: input[:destination_server]).create_exporter
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/content_view_version/destroy_exporter.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module ContentViewVersion
+      class DestroyExporter < Pulp3::Abstract
+        input_format do
+          param :smart_proxy_id, Integer
+          param :exporter_data, Hash
+        end
+
+        def run
+          ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy).destroy_exporter(input[:exporter_data][:pulp_href])
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/content_view_version/export.rb

@@ -0,0 +1,19 @@
+module Actions
+  module Pulp3
+    module ContentViewVersion
+      class Export < Pulp3::AbstractAsyncTask
+        input_format do
+          param :content_view_version_id, Integer
+          param :smart_proxy_id, Integer
+          param :exporter_data, Hash
+        end
+
+        def invoke_external_task
+          cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
+                                                   content_view_version: cvv).create_export(input[:exporter_data][:pulp_href])
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,12 @@
 module Actions
   module Pulp3
     class ImportMigration < Pulp3::Abstract
-      def plan
-        plan_self
+      def plan(options)
+        plan_self(options)
       end
 
       def run
-        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_master)
+        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_primary)
         migration_service.import_pulp3_content
       end
     end

data/app/lib/actions/pulp3/orchestration/content_view_version/export.rb

@@ -0,0 +1,69 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module ContentViewVersion
+        class Export < Actions::EntryAction
+          input_format do
+            param :smart_proxy_id, Integer
+            param :content_view_version_id, Integer
+            param :export_history_id, Integer
+            param :exporter_data, Hash
+            param :destination_server, String
+          end
+
+          output_format do
+            param :exported_file_name, String
+            param :exported_file_checksum, String
+          end
+
+          def plan(content_view_version, destination_server:)
+            action_subject(content_view_version)
+            unless File.directory?(Setting['pulpcore_export_destination'])
+              fail ::Foreman::Exception, N_("Unable to export. 'pulpcore_export_destination' setting is not set to a valid directory.")
+            end
+
+            sequence do
+              smart_proxy = SmartProxy.pulp_primary!
+              action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
+                                     content_view_version_id: content_view_version.id,
+                                     smart_proxy_id: smart_proxy.id,
+                                     destination_server: destination_server).output
+
+              plan_action(::Actions::Pulp3::ContentViewVersion::Export,
+                                     content_view_version_id: content_view_version.id,
+                                     smart_proxy_id: smart_proxy.id,
+                                     exporter_data: action_output[:exporter_data]
+                                     )
+
+              plan_self(exporter_data: action_output[:exporter_data], smart_proxy_id: smart_proxy.id,
+                        destination_server: destination_server,
+                        content_view_version_id: content_view_version.id)
+
+              plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
+                            smart_proxy_id: smart_proxy.id,
+                            exporter_data: action_output[:exporter_data])
+            end
+          end
+
+          def run
+            smart_proxy = ::SmartProxy.find(input[:smart_proxy_id])
+            api = ::Katello::Pulp3::Api::Core.new(smart_proxy)
+            export_data = api.export_api.list(input[:exporter_data][:pulp_href]).results.first
+            output[:exported_file_name], output[:exported_file_checksum] = export_data.output_file_info.first
+            ::Katello::ContentViewVersionExportHistory.create!(content_view_version_id: input[:content_view_version_id],
+                                                               destination_server: input[:destination_server],
+                                                               path: File.dirname(output[:exported_file_name].to_s))
+          end
+
+          def humanized_name
+            _("Export")
+          end
+
+          def rescue_strategy
+            Dynflow::Action::Rescue::Skip
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,8 +16,7 @@ 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)

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

@@ -8,7 +8,7 @@ module Actions
               create_action = plan_action(Actions::Pulp3::Repository::Create, repository, smart_proxy)
               plan_action(Actions::Pulp3::Repository::SaveVersion, repository, repository_details: create_action.output[:response])
 
-              if repository.content_view.default? || !smart_proxy.pulp_master?
+              if repository.content_view.default? || !smart_proxy.pulp_primary?
                 plan_action(Actions::Pulp3::Repository::CreateRemote, repository, smart_proxy)
               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/orchestration/repository/upload_content.rb

@@ -6,7 +6,7 @@ module Actions
           include Actions::Helpers::OutputPropagator
           def plan(repository, smart_proxy, file, unit_type_id)
             sequence do
-              content_backend_service = SmartProxy.pulp_master.content_service(unit_type_id)
+              content_backend_service = SmartProxy.pulp_primary.content_service(unit_type_id)
               content_list = content_backend_service.content_api.list("sha256": Digest::SHA256.hexdigest(File.read(file[:path])))
               content_href = content_list&.results&.first&.pulp_href
 

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_units.rb

@@ -14,7 +14,7 @@ module Actions
                       unit_map: unit_map,
                       dependency_solving: options[:dependency_solving],
                       incremental_update: options[:incremental_update],
-                      smart_proxy_id: SmartProxy.pulp_master.id).output
+                      smart_proxy_id: SmartProxy.pulp_primary.id).output
             plan_action(Pulp3::Repository::SaveVersions, repo_map.values.pluck(:dest_repo),
                         tasks: action_output[:pulp_tasks]).output
           end
@@ -46,7 +46,7 @@ module Actions
 
           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])
+            output[:pulp_tasks] = target_repo.backend_service(SmartProxy.pulp_primary).multi_copy_units(repo_map, input[:dependency_solving])
           end
         end
       end

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

@@ -6,11 +6,16 @@ module Actions
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         def plan(repository, smart_proxy, options = {})
+          smart_proxy = SmartProxy.find_by(id: smart_proxy) #support bulk actions
           sequence do
-            options = {:repository_id => repository.id, :smart_proxy_id => smart_proxy.id}
-            options[:contents_changed] if options.key?(:contents_changed)
-            plan_action(::Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
-            action = plan_self(options)
+            if !repository.unprotected && !options[:assume_content_guard_exists]
+              plan_action(::Actions::Pulp3::ContentGuard::Refresh, smart_proxy)
+            end
+
+            refresh_options = {:repository_id => repository.id, :smart_proxy_id => smart_proxy.id}
+            refresh_options[:contents_changed] if options.key?(:contents_changed)
+            action = plan_self(refresh_options)
+
             plan_action(SaveDistributionReferences, repository, smart_proxy,
                         action.output, :contents_changed => options[:contents_changed])
           end
@@ -18,7 +23,8 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).with_mirror_adapter.refresh_distributions
+          #used in switchover, need to assume pulp3
+          repo.backend_service(smart_proxy, true).with_mirror_adapter.refresh_distributions
         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_artifact.rb

@@ -10,7 +10,7 @@ module Actions
         def invoke_external_task
           artifact_href = input[:tasks].last[:created_resources].first
           content_type = input[:unit_type_id]
-          content_backend_service = SmartProxy.pulp_master.content_service(content_type)
+          content_backend_service = SmartProxy.pulp_primary.content_service(content_type)
           output[:pulp_tasks] = [content_backend_service.content_api.create(input[:options][:file_name], artifact: artifact_href)]
         end
       end

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

@@ -14,9 +14,9 @@ module Actions
             distribution_hrefs.compact!
             repo = ::Katello::Repository.find(input[:repository_id])
             if distribution_hrefs.any?
-              repo.backend_service(smart_proxy).save_distribution_references(distribution_hrefs)
+              repo.backend_service(smart_proxy, true).save_distribution_references(distribution_hrefs)
             else
-              repo.backend_service(smart_proxy).update_distribution
+              repo.backend_service(smart_proxy, true).update_distribution
             end
           end
         end

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

@@ -3,35 +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].present?
+          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
-          end
-
-          unless version_href
-            if input[:repository_details]
-              version_href = input[:repository_details][:latest_version_href]
-            elsif repo.version_href.nil?
-              # Fetch latest Pulp 3 repo version
-              repo_backend_service = repo.backend_service(SmartProxy.pulp_master)
-              version_href ||= repo_backend_service.api.
-                repositories_api.read(repo_backend_service.
-                repository_reference.repository_href).latest_version_href
-            end
+          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_primary)
+          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