katello 4.5.1 → 4.8.0.rc2

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

@@ -4,12 +4,6 @@ module Actions
       middleware.use ::Actions::Middleware::RemoteAction
       middleware.use Actions::Middleware::Pulp3ServicesCheck
 
-      BACKEND_SERVICE_TYPE = 'pulp3'.freeze
-
-      def self.backend_service_type
-        BACKEND_SERVICE_TYPE
-      end
-
       def smart_proxy
         SmartProxy.unscoped.find(input[:smart_proxy_id])
       end

data/app/lib/actions/pulp3/alternate_content_source/create.rb

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Create < Pulp3::Abstract
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def run
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).create
+          smart_proxy_acs_id = input[:smart_proxy_acs_id]
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(smart_proxy_acs_id)
+          output[:response] = smart_proxy_acs.backend_service.create
         end
 
         def rescue_strategy

data/app/lib/actions/pulp3/alternate_content_source/create_remote.rb

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class CreateRemote < Pulp3::Abstract
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def run
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).create_remote
+          smart_proxy_acs_id = input[:smart_proxy_acs_id]
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(smart_proxy_acs_id)
+          output[:response] = smart_proxy_acs.backend_service.create_remote
         end
 
         def rescue_strategy

data/app/lib/actions/pulp3/alternate_content_source/delete.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Delete < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).delete_alternate_content_source
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.delete_alternate_content_source
         end
       end
     end

data/app/lib/actions/pulp3/alternate_content_source/delete_remote.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class DeleteRemote < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs, options = {})
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id, old_url: options[:old_url])
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).delete_remote
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.delete_remote(old_url: input[:old_url])
         end
       end
     end

data/app/lib/actions/pulp3/alternate_content_source/refresh.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Refresh < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).refresh
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.refresh
         end
 
         def rescue_strategy_for_self

data/app/lib/actions/pulp3/alternate_content_source/refresh_remote.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class RefreshRemote < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
+        end
+
+        def invoke_external_task
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          smart_proxy_acs.backend_service.update_remote
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/alternate_content_source/update.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Update < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).update
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.update
         end
       end
     end

data/app/lib/actions/pulp3/alternate_content_source/update_remote.rb

@@ -2,14 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class UpdateRemote < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          acs.backend_service(smart_proxy).create_test_remote
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          smart_proxy_acs.backend_service.create_test_remote
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).update_remote
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.update_remote
         end
       end
     end

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

@@ -12,6 +12,7 @@ module Actions
             end
             repository_hrefs = ::Katello::Pulp3::Api::Core.new(smart_proxy).core_repositories_list_all(fields: 'pulp_href').map(&:pulp_href)
           end
+          fail _('There is no downloaded content to clean.') if repository_hrefs.empty?
           plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
         end
 

data/app/lib/actions/pulp3/content_view/delete_repository_references.rb

@@ -14,8 +14,7 @@ module Actions
           to_delete = content_view.repository_references.select do |repository_reference|
             repo = repository_reference.root_repository.library_instance
             if delete_href?(repository_reference.repository_href, content_view)
-              #force pulp3 in case we've done migrations, but haven't switched over yet
-              tasks << repo.backend_service(smart_proxy, true).delete_repository(repository_reference)
+              tasks << repo.backend_service(smart_proxy).delete_repository(repository_reference)
               true
             else
               false

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

@@ -6,6 +6,7 @@ module Actions
           param :smart_proxy_id, Integer
           param :base_path, String
           param :content_view_version_id, Integer
+          param :from_content_view_version_id, Integer
           param :destination_server, String
         end
 
@@ -18,8 +19,10 @@ module Actions
           smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
           output[:path] = input[:base_path]
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
           export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.create(
                                                      content_view_version: cvv,
+                                                     from_content_view_version: from_cvv,
                                                      smart_proxy: smart_proxy,
                                                      format: input[:format]).generate_metadata
 
@@ -30,6 +33,7 @@ module Actions
             metadata: export_metadata,
             audit_comment: ::Katello::ContentViewVersionExportHistory.generate_audit_comment(content_view_version: cvv,
                                                                                              user: User.current,
+                                                                                             from_version: from_cvv,
                                                                                              metadata: export_metadata)
           )
           output[:export_history_id] = history.id

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

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Create < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Create, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Create, smart_proxy_acs)
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/delete.rb

@@ -3,18 +3,17 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Delete < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs, options = {})
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::Delete, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, acs, smart_proxy)
-              plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Actions::Pulp3::AlternateContentSource::Delete, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, smart_proxy_acs, options)
+              plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
             end
           end
 
           def finalize
-            acs_id = input[:acs_id]
-            smart_proxy_id = input[:smart_proxy_id]
-            ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs_id, smart_proxy_id: smart_proxy_id).destroy
+            smart_proxy_acs_id = input[:smart_proxy_acs_id]
+            ::Katello::SmartProxyAlternateContentSource.find_by(id: smart_proxy_acs_id).destroy
           end
         end
       end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/refresh.rb

@@ -3,9 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Refresh < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::RefreshRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, smart_proxy_acs)
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/update.rb

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Update < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Update, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Update, smart_proxy_acs)
             end
           end
         end

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

@@ -13,7 +13,7 @@ module Actions
                                                     mirror: content_view_version.content_view.generated?)
                   plan_action(Actions::Pulp3::Repository::SaveVersion, repo.library_instance)
                   plan_action(Katello::Repository::IndexContent, id: repo.library_instance_id)
-                  plan_action(Katello::Repository::MetadataGenerate, repo.library_instance, :force => true)
+                  plan_action(Katello::Repository::MetadataGenerate, repo.library_instance, force_publication: true)
                 end
               end
             end

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

@@ -17,17 +17,29 @@ module Actions
             param :exported_file_checksum, Hash
             param :export_path, String
           end
+
           def plan(content_view_version:, destination_server: nil,
                    chunk_size: nil, from_history: nil,
                    validate_incremental: true,
                    fail_on_missing_content: false,
                    format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             smart_proxy = SmartProxy.pulp_primary!
+            from_content_view_version = from_history&.content_view_version
+            export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
+                smart_proxy: smart_proxy,
+                content_view_version: content_view_version,
+                destination_server: destination_server,
+                from_content_view_version: from_content_view_version,
+                format: format)
+            export_service.validate!(fail_on_missing_content: fail_on_missing_content,
+                                     validate_incremental: validate_incremental,
+                                     chunk_size: chunk_size)
 
             if format == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
               sequence do
                 export_output = plan_action(SyncableExport,
                           content_view_version: content_view_version,
+                          from_content_view_version: from_history&.content_view_version,
                           smart_proxy: smart_proxy,
                           destination_server: destination_server).output
                 plan_self(export_history_id: export_output[:export_history_id],
@@ -37,17 +49,6 @@ module Actions
             end
 
             sequence do
-              from_content_view_version = from_history&.content_view_version
-              export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
-                  smart_proxy: smart_proxy,
-                  content_view_version: content_view_version,
-                  destination_server: destination_server,
-                  from_content_view_version: from_content_view_version,
-                  format: format)
-              export_service.validate!(fail_on_missing_content: fail_on_missing_content,
-                                       validate_incremental: validate_incremental,
-                                       chunk_size: chunk_size)
-
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
                                           content_view_version_id: content_view_version.id,
                                           smart_proxy_id: smart_proxy.id,

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

@@ -10,11 +10,11 @@ module Actions
                                  format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             action_subject(organization)
             validate_repositories_immediate!(organization) if fail_on_missing_content
-
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_library_export_view(destination_server: destination_server,
                                                                            organization: organization,
-                                                                           create_by_default: true)
-            repo_ids_in_library = organization.default_content_view_version.repositories.exportable.immediate_or_none.pluck(:id)
+                                                                           create_by_default: true,
+                                                                           format: format)
+            repo_ids_in_library = organization.default_content_view_version.repositories.exportable(format: format).immediate_or_none.pluck(:id)
             content_view.update!(repository_ids: repo_ids_in_library)
 
             sequence do

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

@@ -9,10 +9,11 @@ module Actions
                     format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             action_subject(repository)
             validate_repositories_immediate!(repository)
-
+            validate_export_types!(repository, format)
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
                                                                            repository: repository,
-                                                                           create_by_default: true)
+                                                                           create_by_default: true,
+                                                                           format: format)
             content_view.update!(repository_ids: [repository.library_instance_or_self.id])
 
             sequence do
@@ -39,13 +40,26 @@ module Actions
           end
 
           def validate_repositories_immediate!(repository)
-            unless repository.immediate?
+            unless repository.download_policy.blank? || repository.immediate?
               fail _("NOTE: Unable to fully export repository '%{repository}' because"\
                      " it does not have the 'immediate' download policy."\
                      " Update the download policy and sync the affected repository to include them in the export."\
                        % { repository: repository.name })
             end
           end
+
+          def validate_export_types!(repository, format)
+            return if ::Katello::Repository.exportable(format: format).where(id: repository.id).exists?
+            if format == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+              fail _("NOTE: Unable to export repository '%{repository}' because"\
+                     " it does not have an syncably exportable content type."\
+                       % { repository: repository.name })
+            end
+
+            fail _("NOTE: Unable to export repository '%{repository}' because"\
+                   " it does not have an exportable content type."\
+                     % { repository: repository.name })
+          end
         end
       end
     end

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

@@ -8,6 +8,7 @@ module Actions
             param :content_view_version_id, Integer
             param :export_history_id, Integer
             param :export_path, String
+            param :from_content_view_version_id, Integer
           end
 
           output_format do
@@ -17,16 +18,16 @@ module Actions
 
           def plan(content_view_version:,
                    smart_proxy:,
-                   fail_on_missing_content: false,
-                   destination_server:)
+                   destination_server:,
+                   from_content_view_version:)
             format = ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
             sequence do
               export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
                   smart_proxy: smart_proxy,
                   content_view_version: content_view_version,
+                  from_content_view_version: from_content_view_version,
                   format: format,
                   destination_server: destination_server)
-              export_service.validate!(fail_on_missing_content: fail_on_missing_content)
               base_path = export_service.generate_exporter_path
               export_service.repositories.each do |repository|
                 action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
@@ -42,7 +43,8 @@ module Actions
                             smart_proxy_id: smart_proxy.id,
                             exporter_data: action_output[:exporter_data],
                             format: format,
-                            repository_id: repository.id)
+                            repository_id: repository.id,
+                            from_content_view_version_id:  from_content_view_version&.id)
 
                 plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
                           smart_proxy_id: smart_proxy.id,
@@ -55,6 +57,7 @@ module Actions
                   ::Actions::Pulp3::ContentViewVersion::CreateSyncableExportHistory,
                   smart_proxy_id: smart_proxy.id,
                   content_view_version_id: content_view_version.id,
+                  from_content_view_version_id:  from_content_view_version&.id,
                   destination_server: destination_server,
                   format: format,
                   base_path: base_path

data/app/lib/actions/pulp3/orchestration/orphan_cleanup/remove_orphans.rb

@@ -11,6 +11,7 @@ module Actions
                 if proxy.pulp_mirror?
                   plan_action(Actions::Pulp3::OrphanCleanup::RemoveUnneededRepos, proxy)
                   plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanDistributions, proxy)
+                  plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanAlternateContentSources, proxy)
                   plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanRemotes, proxy)
                 end
               end

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

@@ -24,6 +24,7 @@ module Actions
                   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|
+                    # TODO: In a future refactor, can :copy_all be utilized?  Filters should not be needed in this code segment.
                     copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent, source_repo, smart_proxy, target_repo,
                                                 filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                                 rpm_filenames: rpm_filenames, remove_all: false)

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

@@ -16,7 +16,7 @@ module Actions
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
               plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
-              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if repository.environment
+              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if Setting[:distribute_archived_cvv] || repository.environment
             end
           end
 

data/app/lib/actions/pulp3/orphan_cleanup/delete_orphan_alternate_content_sources.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module OrphanCleanup
+      class DeleteOrphanAlternateContentSources < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy)
+          plan_self(:smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          smart_proxy_service = ::Katello::Pulp3::SmartProxyRepository.instance_for_type(smart_proxy)
+          smart_proxy_service.delete_orphan_alternate_content_sources
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Actions
       class ReclaimSpace < Pulp3::AbstractAsyncTask
         def plan(repo, smart_proxy = SmartProxy.pulp_primary)
           action_subject(repo)
-          repository_hrefs = ::Katello::Pulp3::RepositoryReference.default_cv_repository_hrefs([repo], Organization.current || repositories.first.organization)
+          repository_hrefs = ::Katello::Pulp3::RepositoryReference.default_cv_repository_hrefs([repo], repo.organization)
           plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
         end
 

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

@@ -23,8 +23,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          #used in switchover, need to assume pulp3
-          repo.backend_service(smart_proxy, true).with_mirror_adapter.refresh_distributions
+          repo.backend_service(smart_proxy).with_mirror_adapter.refresh_distributions
         end
       end
     end

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

@@ -3,7 +3,7 @@ module Actions
     module Repository
       class Repair < Pulp3::AbstractAsyncTask
         include Helpers::Presenter
-        def plan(repository_id, smart_proxy)
+        def plan(repository_id, smart_proxy = SmartProxy.pulp_primary)
           plan_self(:repository_id => repository_id, :smart_proxy_id => smart_proxy.id)
         end
 

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

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

data/app/lib/katello/api/v2/error_handling.rb

@@ -21,6 +21,7 @@ module Katello
           rescue_from Errors::UnsupportedActionException, :with => :rescue_from_unsupported_action_exception
           rescue_from Errors::MaxHostsReachedException, :with => :rescue_from_max_hosts_reached_exception
           rescue_from Errors::CdnSubstitutionError, :with => :rescue_from_bad_data
+          rescue_from Katello::Pulp3::ContentViewVersion::ExportValidationError, :with => :rescue_from_export_validation_error
           rescue_from Errors::RegistrationError, :with => :rescue_from_bad_data
           rescue_from ActionController::ParameterMissing, :with => :rescue_from_missing_param
           rescue_from ::ForemanTasks::Lock::LockConflict, :with => :rescue_from_bad_data
@@ -85,6 +86,10 @@ module Katello
           respond_for_exception(exception, :status => :conflict, :with_logging => false)
         end
 
+        def rescue_from_export_validation_error(exception)
+          respond_for_exception(exception, :force_json => true, :status => :unprocessable_entity)
+        end
+
         def rescue_from_conflict_exception(exception)
           respond_for_exception(exception, :status => :conflict)
         end
@@ -122,11 +127,16 @@ module Katello
           options[:errors] = exception.try(:record).try(:errors) || [exception.message]
 
           logger.error pp_exception(exception) if options[:with_logging]
-
           respond_to do |format|
             #json has to be displayMessage for older RHEL 5.7 subscription managers
             format.json { render :json => { :displayMessage => options[:display_message], :errors => options[:errors]}, :status => options[:status] }
-            format.all { render :plain => options[:text], :status => options[:status] }
+            format.all do
+              if options[:force_json]
+                render :json => { :displayMessage => options[:display_message], :errors => options[:errors]}, :status => options[:status]
+              else
+                render :plain => options[:text], :status => options[:status]
+              end
+            end
           end
         end
 

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -161,7 +161,7 @@ module Katello
         returns String, desc: 'Package version'
       end
       def host_latest_applicable_rpm_version(host, package)
-        host.applicable_rpms.where(name: package).order(:version_sortable).limit(1).pluck(:nvra).first
+        ::Katello::Rpm.latest(host.applicable_rpms.where(name: package)).first.nvra
       end
 
       apipie :method, 'Loads Pool objects' do
@@ -240,14 +240,17 @@ module Katello
           seen_host_ids &= only_host_ids if only_host_ids
 
           # preload errata in one query for this batch
-          preloaded_errata = Katello::Erratum.where(:errata_id => seen_errata_ids).pluck(:errata_id, :errata_type)
+          preloaded_errata = Katello::Erratum.where(:errata_id => seen_errata_ids).pluck(:errata_id, :errata_type, :issued)
           preloaded_hosts = ::Host.where(:id => seen_host_ids).includes(:reported_data)
 
           batch.each do |task|
             next if skip_task?(task)
-            next unless only_host_ids.nil? || only_host_ids.include?(task.input['host']['id'].to_i)
+            next unless only_host_ids.nil? || only_host_ids.include?(get_task_input(task)['host']['id'].to_i)
             parse_errata(task).each do |erratum_id|
-              current_erratum_errata_type = preloaded_errata.find { |k, _| k == erratum_id }.last
+              current_erratum = preloaded_errata.find { |k, _| k == erratum_id }
+              next if current_erratum.nil?
+              current_erratum_errata_type = current_erratum[1]
+              current_erratum_issued = current_erratum.last
 
               if filter_errata_type != 'all'
                 next unless filter_errata_type == current_erratum_errata_type
@@ -258,6 +261,7 @@ module Katello
                 :hostname => get_task_input(task)['host']['name'],
                 :erratum_id => erratum_id,
                 :erratum_type => current_erratum_errata_type,
+                :issued => current_erratum_issued,
                 :status => task.result
               }
 

data/app/lib/katello/concerns/renderer_extensions.rb

@@ -8,10 +8,11 @@ module Katello
           super
 
           medium_provider = Katello::ManagedContentMediumProvider.new(host)
-          content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
+          content_view = host.try(:content_facet).try(:single_content_view) || host.try(:single_content_view)
 
           if content_view && host.operatingsystem.is_a?(Redhat) &&
-                  host.operatingsystem.kickstart_repos(host).first.present?
+                  host.operatingsystem.kickstart_repos(host).first.present? &&
+                  host&.content_facet&.kickstart_repository.present?
             @mediapath ||= host.operatingsystem.mediumpath(medium_provider)
           end
         end