katello 4.5.1 → 4.8.0.rc2

data/app/services/katello/pulp3/content_view_version/metadata_generator.rb

@@ -23,7 +23,6 @@ module Katello
                   incremental: from_content_view_version.present?,
                   format: export_service.format
           }
-
           unless from_content_view_version.blank?
             ret[:from_content_view_version] = from_content_view_version.slice(:major, :minor)
           end
@@ -45,10 +44,11 @@ module Katello
 
         def generate_repository_metadata(repo)
           repo.slice(:name, :label, :description, :arch, :content_type, :unprotected,
-                     :checksum_type, :os_versions, :major, :minor, :download_policy, :mirroring_policy).
+                     :checksum_type, :os_versions, :major, :minor,
+                     :download_policy, :mirroring_policy).
             merge(product: generate_product_metadata(repo.product),
                   gpg_key: generate_gpg_metadata(repo.gpg_key),
-                  content: generate_content_metadata(repo.content),
+                  content: generate_content_metadata(repo),
                   redhat: repo.redhat?)
         end
 
@@ -63,9 +63,16 @@ module Katello
           gpg.slice(:name, :content_type, :content)
         end
 
-        def generate_content_metadata(content)
+        def generate_content_metadata(repo)
+          content = repo.content
           return {} if content.blank?
-          { id: content.cp_content_id, label: content.label }
+          content_data = Katello::Content.substitute_content_path(arch: repo.arch,
+                                                                   releasever: repo.minor,
+                                                                   content_path: content.content_url)
+          { id: content.cp_content_id,
+            label: content.label,
+            url: content_data[:path]
+          }
         end
 
         def zip_gpg_keys(entities)

data/app/services/katello/pulp3/content_view_version/metadata_map.rb

@@ -20,7 +20,8 @@ module Katello
                     :gpg_keys,
                     :content_view,
                     :content_view_version,
-                    :from_content_view_version
+                    :from_content_view_version,
+                    :format
 
         def initialize(metadata:)
           @toc = metadata[:toc]
@@ -30,6 +31,11 @@ module Katello
           @content_view = parse_content_view(metadata[:content_view]) if metadata[:content_view]
           @content_view_version = parse_content_view_version(metadata[:content_view_version]) if metadata[:content_view_version]
           @from_content_view_version = parse_content_view_version(metadata[:from_content_view_version]) if metadata[:from_content_view_version]
+          @format = metadata[:format]
+        end
+
+        def syncable_format?
+          @format == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
         end
 
         private
@@ -76,6 +82,11 @@ module Katello
 
         def parse_repositories(repositories)
           repositories.map do |pulp_name, repo|
+            if repo[:content]
+              content =  MetadataRepositoryContent.new(id: repo[:content][:id],
+                                                       label: repo[:content][:label],
+                                                       url: repo[:content][:url])
+            end
             MetadataRepository.new(
               pulp_name: pulp_name,
               name: repo[:name],
@@ -93,7 +104,7 @@ module Katello
               redhat: repo[:redhat],
               product: product_for_repo(repo),
               gpg_key: gpg_key_for_repo(repo),
-              content: repo[:content] ? MetadataRepositoryContent.new(id: repo[:content][:id], label: repo[:content][:label]) : nil
+              content: content
             )
           rescue => e
             raise _("Invalid repository in the metadata %{repo} error=%{error}") % { repo: repo, error: e.message }

data/app/services/katello/pulp3/content_view_version/syncable_format_export.rb

@@ -9,7 +9,13 @@ module Katello
         end
 
         def create_export(exporter_data, _options = {})
-          [api.yum_export_api.create(exporter_data[:pulp_href], publication: repository.publication_href)]
+          options = { publication: repository.publication_href }
+          if incremental?
+            from_exporter = Export.new(smart_proxy: smart_proxy, content_view_version: from_content_view_version)
+            from_repo = from_exporter.repositories.find_by(library_instance_id: repository.library_instance)
+            options[:start_repository_version] = from_repo.version_href unless from_repo.blank?
+          end
+          [api.yum_export_api.create(exporter_data[:pulp_href], options)]
         end
 
         def fetch_export(exporter_href)
@@ -24,7 +30,11 @@ module Katello
         end
 
         def generate_repository_exporter_path
-          _org, _content, content_path = repository.library_instance_or_self.relative_path.split("/", 3)
+          if repository.docker?
+            content_path = repository.library_instance_or_self.relative_path
+          else
+            _org, _content, content_path = repository.library_instance_or_self.relative_path.split("/", 3)
+          end
           content_path = content_path.sub(%r|^/|, '')
           "#{generate_exporter_path}/#{content_path}".gsub(/\s/, '_')
         end

data/app/services/katello/pulp3/docker_manifest.rb

@@ -16,7 +16,8 @@ module Katello
 
       def self.content_unit_list(page_opts)
         page_opts[:media_type] = ['application/vnd.docker.distribution.manifest.v1+json',
-                                  'application/vnd.docker.distribution.manifest.v2+json']
+                                  'application/vnd.docker.distribution.manifest.v2+json',
+                                  'application/vnd.oci.image.manifest.v1+json']
         self.content_api.list(page_opts)
       end
 

data/app/services/katello/pulp3/docker_manifest_list.rb

@@ -14,7 +14,8 @@ module Katello
       end
 
       def self.content_unit_list(page_opts)
-        page_opts[:media_type] = ["application/vnd.docker.distribution.manifest.list.v2+json"]
+        page_opts[:media_type] = ['application/vnd.docker.distribution.manifest.list.v2+json',
+                                  'application/vnd.oci.image.index.v1+json']
         self.content_api.list(page_opts)
       end
 

data/app/services/katello/pulp3/erratum.rb

@@ -28,6 +28,7 @@ module Katello
       def self.generate_model_row(unit)
         keys = %w(title id severity issued_date type description reboot_suggested solution updated_date summary)
         custom_json = unit.slice(*keys)
+        custom_json.inject(HashWithIndifferentAccess.new({})) { |h, (k, v)| h.merge({ k => v.respond_to?(:strip) ? v.strip : v }) }
         custom_json['pulp_id'] = custom_json['id']
         custom_json["issued"] = custom_json.delete("issued_date")
         custom_json["updated"] = custom_json.delete("updated_date")

data/app/services/katello/pulp3/module_stream.rb

@@ -25,16 +25,25 @@ module Katello
       end
 
       def self.build_artifacts(katello_id, artifacts_json)
-        return [] if artifacts_json.nil?
-        artifacts = artifacts_json.map do |name|
-          {name: name,
-           module_stream_id: katello_id}
+        # TODO: Fully support artifact hashes
+        # => {"rpms"=>["swig"], "description"=>"Simplified Wrapper and Interface Generator (SWIG)"}
+        return [] if artifacts_json.empty?
+
+        if artifacts_json.is_a?(::Hash)
+          artifacts = artifacts_json['rpms'].map do |name|
+            {name: name, module_stream_id: katello_id}
+          end
+        else
+          # For compatibility with pulpcore 3.21 + pulp-rpm 3.18 and below.
+          artifacts = artifacts_json.map do |name|
+            {name: name, module_stream_id: katello_id}
+          end
         end
         add_timestamps(artifacts)
       end
 
       def self.build_profiles(katello_id, profiles_json)
-        return [] if profiles_json.nil?
+        return [] if profiles_json.empty?
         profiles = profiles_json.map do |profile, _rpms|
           {
             module_stream_id: katello_id,
@@ -45,14 +54,20 @@ module Katello
       end
 
       def self.build_profile_rpms(katello_id, profiles_json)
+        # TODO: Fully support artifact hashes
+        # => {"rpms"=>["swig"], "description"=>"Simplified Wrapper and Interface Generator (SWIG)"}
         return [] if profiles_json.nil?
-        profile_rpms = profiles_json.map do |profile, rpms|
+        profile_rpms = profiles_json.map do |profile, artifacts_json|
           profile_id = Katello::ModuleProfile.find_by(module_stream_id: katello_id, name: profile).id
-          rpms.map do |rpm|
-            {
-              module_profile_id: profile_id,
-              name: rpm
-            }
+          if artifacts_json.is_a?(::Hash)
+            artifacts_json['rpms'].map do |rpm|
+              {name: rpm, module_profile_id: profile_id}
+            end
+          else
+            # For compatibility with pulpcore 3.21 + pulp-rpm 3.18 and below.
+            artifacts_json.map do |rpm|
+              {name: rpm, module_profile_id: profile_id}
+            end
           end
         end
         add_timestamps(profile_rpms.flatten)

data/app/services/katello/pulp3/pulp_content_unit.rb

@@ -17,6 +17,9 @@ module Katello
           repository_type = Katello::Repository.find(opts[:repository_id]).repository_type
           content_type = opts[:content_type]
           self.content_api(repository_type, content_type).create(relative_path, opts)
+        elsif self.content_type == 'rpm' || self.content_type == 'srpm'
+          # The pulp_rpm API bindings expect relative_path to be within the options hash.
+          self.content_api.create(opts)
         else
           self.content_api.create(relative_path, opts)
         end

data/app/services/katello/pulp3/repository/apt.rb

@@ -4,6 +4,7 @@ module Katello
   module Pulp3
     class Repository
       class Apt < ::Katello::Pulp3::Repository
+        UNIT_LIMIT = 10_000
         SIGNING_SERVICE_NAME = 'katello_deb_sign'.freeze
 
         def remote_options
@@ -23,6 +24,12 @@ module Katello
           common_remote_options.merge(deb_remote_options)
         end
 
+        def sync_url_params(sync_options)
+          params = super
+          params[:optimize] = sync_options[:optimize] if sync_options.key?(:optimize)
+          params
+        end
+
         def mirror_remote_options
           super.merge(
             {
@@ -66,8 +73,191 @@ module Katello
           "/pulp/deb/#{repo.relative_path}/".sub('//', '/')
         end
 
-        def copy_content_for_source(source_repository, _options = {})
-          copy_units_by_href(source_repository.debs.pluck(:pulp_id))
+        def multi_copy_units(repo_id_map, dependency_solving)
+          tasks = []
+
+          if repo_id_map.values.pluck(:content_unit_hrefs).flatten.any?
+            data = PulpDebClient::Copy.new
+            data.dependency_solving = dependency_solving
+            data.config = []
+            repo_id_map.each do |source_repo_ids, dest_repo_id_map|
+              dest_repo = ::Katello::Repository.find(dest_repo_id_map[:dest_repo])
+              dest_repo_href = ::Katello::Pulp3::Repository::Apt.new(dest_repo, SmartProxy.pulp_primary).repository_reference.repository_href
+              content_unit_hrefs = dest_repo_id_map[:content_unit_hrefs]
+              # Not needed during incremental update due to dest_base_version
+              source_repo_ids.each do |source_repo_id|
+                source_repo_version = ::Katello::Repository.find(source_repo_id).version_href
+                config = { source_repo_version: source_repo_version, dest_repo: dest_repo_href, content: content_unit_hrefs }
+                config[:dest_base_version] = dest_repo_id_map[:base_version] if dest_repo_id_map[:base_version]
+                data.config << config
+              end
+            end
+            tasks << copy_content_chunked(data)
+          else
+            tasks << remove_all_content_from_mapping(repo_id_map)
+          end
+          tasks.flatten
+        end
+
+        def copy_api_data_dup(data)
+          data_dup = PulpDebClient::Copy.new
+          data_dup.dependency_solving = data.dependency_solving
+          data_dup.config = []
+          data.config.each do |repo_config|
+            config_hash = {
+              source_repo_version: repo_config[:source_repo_version],
+              dest_repo: repo_config[:dest_repo],
+              content: []
+            }
+            config_hash[:dest_base_version] = repo_config[:dest_base_version] if repo_config[:dest_base_version]
+            data_dup.config << config_hash
+          end
+          data_dup
+        end
+
+        def copy_content_chunked(data)
+          tasks = []
+          # Don't chunk if there aren't enough content units
+          if data.config.sum { |repo_config| repo_config[:content].size } <= UNIT_LIMIT
+            return api.copy_api.copy_content(data)
+          end
+
+          unit_copy_counter = 0
+          i = 0
+          leftover_units = data.config.first[:content].deep_dup
+
+          # Copy data and clear its content fields
+          data_dup = copy_api_data_dup(data)
+
+          while i < data_dup.config.size
+            # Copy all units within repo or only some?
+            if leftover_units.length < UNIT_LIMIT - unit_copy_counter
+              copy_amount = leftover_units.length
+            else
+              copy_amount = UNIT_LIMIT - unit_copy_counter
+            end
+
+            data_dup.config[i][:content] = leftover_units.pop(copy_amount)
+            unit_copy_counter += copy_amount
+            if unit_copy_counter != 0
+              tasks << api.copy_api.copy_content(data_dup)
+              unit_copy_counter = 0
+            end
+
+            if leftover_units.empty?
+              # Nothing more to copy -- clear current config's content
+              data_dup.config[i][:content] = []
+              i += 1
+              # Fetch unit list for next data config
+              leftover_units = data.config[i][:content].deep_dup unless i == data_dup.config.size
+            end
+          end
+
+          tasks
+        end
+
+        def remove_all_content_from_mapping(repo_id_map)
+          tasks = []
+          repo_id_map.each do |_source_repo_ids, dest_repo_id_map|
+            dest_repo = ::Katello::Repository.find(dest_repo_id_map[:dest_repo])
+            dest_repo_href = ::Katello::Pulp3::Repository::Apt.new(dest_repo, SmartProxy.pulp_primary).repository_reference.repository_href
+            tasks << remove_all_content_from_repo(dest_repo_href)
+          end
+          tasks
+        end
+
+        def remove_all_content_from_repo(repo_href)
+          data = PulpDebClient::RepositoryAddRemoveContent.new(
+            remove_content_units: ['*'])
+          api.repositories_api.modify(repo_href, data)
+        end
+
+        def remove_all_content
+          data = PulpDebClient::RepositoryAddRemoveContent.new(
+            remove_content_units: ['*'])
+          api.repositories_api.modify(repository_reference.repository_href, data)
+        end
+
+        def add_filter_content(source_repo_ids, filters, filter_list_map)
+          filters.each do |filter|
+            if filter.inclusion
+              source_repo_ids.each do |repo_id|
+                filter_list_map[:whitelist_ids] += filter.content_unit_pulp_ids(::Katello::Repository.find(repo_id))
+              end
+            else
+              source_repo_ids.each do |repo_id|
+                filter_list_map[:blacklist_ids] += filter.content_unit_pulp_ids(::Katello::Repository.find(repo_id))
+              end
+            end
+          end
+          filter_list_map
+        end
+
+        def add_debs(source_repo_ids, filters, filter_list_map)
+          if (filter_list_map[:whitelist_ids].empty? && filters.select { |filter| filter.inclusion }.empty?)
+            filter_list_map[:whitelist_ids] += source_repo_ids.collect do |source_repo_id|
+              source_repo = ::Katello::Repository.find(source_repo_id)
+              source_repo.debs.pluck(:pulp_id).sort
+            end
+          end
+          filter_list_map
+        end
+
+        def copy_content_from_mapping(repo_id_map, options = {})
+          repo_id_map.each do |source_repo_ids, dest_repo_map|
+            filters = ContentViewDebFilter.where(:id => options[:filter_ids])
+
+            filter_list_map = { whitelist_ids: [], blacklist_ids: [] }
+            filter_list_map = add_filter_content(source_repo_ids, filters, filter_list_map)
+            filter_list_map = add_debs(source_repo_ids, filters, filter_list_map)
+
+            whitelist_ids = filter_list_map[:whitelist_ids].flatten&.uniq
+            blacklist_ids = filter_list_map[:blacklist_ids].flatten&.uniq
+            content_unit_hrefs = whitelist_ids - blacklist_ids
+
+            dest_repo_map[:content_unit_hrefs] = content_unit_hrefs.uniq.sort
+          end
+
+          dependency_solving = options[:solve_dependencies] || false
+
+          multi_copy_units(repo_id_map, dependency_solving)
+        end
+
+        def copy_units(content_unit_hrefs, remove_all)
+          remove_all = true if remove_all.nil?
+          tasks = []
+
+          if content_unit_hrefs.sort!.any?
+            first_slice = remove_all
+            content_unit_hrefs.each_slice(UNIT_LIMIT) do |slice|
+              tasks << add_content(slice, first_slice)
+              first_slice = false
+            end
+          else
+            tasks << remove_all_content
+          end
+          tasks
+        end
+
+        def copy_content_for_source(source_repository, options = {})
+          # copy_units_by_href(source_repository.debs.pluck(:pulp_id))
+          filters = ContentViewDebFilter.where(:id => options[:filter_ids])
+
+          whitelist_ids = []
+          blacklist_ids = []
+          filters.each do |filter|
+            if filter.inclusion
+              whitelist_ids += filter.content_unit_pulp_ids(source_repository)
+            else
+              blacklist_ids += filter.content_unit_pulp_ids(source_repository)
+            end
+          end
+
+          whitelist_ids = source_repository.debs.pluck(:pulp_id).sort if (whitelist_ids.empty? && filters.select { |filter| filter.inclusion }.empty?)
+
+          content_unit_hrefs = whitelist_ids - blacklist_ids
+
+          copy_units(content_unit_hrefs.uniq, options[:remove_all])
         end
 
         def regenerate_applicability

data/app/services/katello/pulp3/repository/yum.rb

@@ -12,11 +12,12 @@ module Katello
 
         def remote_options
           options = common_remote_options
-          uri = URI(root.url)
+          uri = root.url ? URI(root.url) : nil
           unless root.upstream_authentication_token.blank?
             options.merge!(sles_auth_token: root.upstream_authentication_token)
           end
-          options.merge!(url: uri.to_s, policy: root.download_policy)
+          options.merge!(url: uri.to_s) if uri
+          options.merge!(policy: root.download_policy)
         end
 
         def publication_options(repository_version)
@@ -209,7 +210,8 @@ module Katello
               tasks << add_content(slice, first_slice)
               first_slice = false
             end
-          else
+          # If we're merging composite cv repositories, don't clear out the Pulp repository.
+          elsif remove_all
             tasks << remove_all_content
           end
           tasks
@@ -438,7 +440,8 @@ module Katello
 
           errata_to_include = filter_errata_by_pulp_href(source_repository.errata, content_unit_hrefs,
                                                          source_repository.rpms.pluck(:filename) +
-                                                         source_repository.srpms.pluck(:filename)) -
+                                                         source_repository.srpms.pluck(:filename),
+                                                         source_repository.module_streams.map(&:module_spec)) -
                                                          all_excluded_errata
           content_unit_hrefs += errata_to_include.collect do |erratum|
             erratum.repository_errata.where(repository_id: source_repository.id).pluck(:erratum_pulp3_href)

data/app/services/katello/pulp3/repository.rb

@@ -55,7 +55,7 @@ module Katello
       end
 
       def repair(repository_version_href)
-        data = api.repository_version_class.new
+        data = api.repair_class.new
         api.repository_versions_api.repair(repository_version_href, data)
       end
 
@@ -77,7 +77,7 @@ module Katello
         if remote_options[:url].blank?
           if href
             repo.update(remote_href: nil)
-            delete_remote href
+            delete_remote(href: href)
           end
         else
           if href
@@ -97,8 +97,9 @@ module Katello
         end
       end
 
-      def delete_remote(href = repo.remote_href)
-        ignore_404_exception { remote_options[:url]&.start_with?('uln') ? api.remotes_uln_api.delete(href) : api.remotes_api.delete(href) } if href
+      def delete_remote(options = {})
+        options[:href] ||= repo.remote_href
+        ignore_404_exception { remote_options[:url]&.start_with?('uln') ? api.remotes_uln_api.delete(options[:href]) : api.remotes_api.delete(options[:href]) } if options[:href]
       end
 
       def self.instance_for_type(repo, smart_proxy)
@@ -199,7 +200,7 @@ module Katello
 
       def sync_url_params(_sync_options)
         params = {remote: repo.remote_href, mirror: repo.root.mirroring_policy == Katello::RootRepository::MIRRORING_POLICY_CONTENT}
-        params[:skip_types] = skip_types if skip_types
+        params[:skip_types] = skip_types if (skip_types && repo.root.mirroring_policy != Katello::RootRepository::MIRRORING_POLICY_COMPLETE)
         params
       end
 
@@ -298,7 +299,7 @@ module Katello
           tasks << api.repositories_api.modify(repository_reference.repository_href, remove_content_units: ['*'])
         end
 
-        if options[:mirror]
+        if options[:mirror] && api.class.respond_to?(:add_remove_content_class)
           data = api.class.add_remove_content_class.new(
                     base_version: source_repository.version_href)
 
@@ -384,6 +385,8 @@ module Katello
         remote_options[:download_concurrency] = root.download_concurrency unless root.download_concurrency.blank?
         remote_options.merge!(username: root&.upstream_username,
                               password: root&.upstream_password)
+        remote_options[:username] = nil if remote_options[:username] == ''
+        remote_options[:password] = nil if remote_options[:password] == ''
         remote_options.merge!(ssl_remote_options)
       end
 
@@ -417,27 +420,39 @@ module Katello
       end
 
       def ssl_remote_options
+        options = {}
         if root.redhat? && root.cdn_configuration.redhat_cdn?
-          {
+          options = {
             client_cert: root.product.certificate,
             client_key: root.product.key,
             ca_cert: Katello::Repository.feed_ca_cert(root.url)
           }
+        elsif root.redhat? && root.cdn_configuration.custom_cdn?
+          options = {
+            ca_cert: root.cdn_configuration.ssl_ca
+          }
         elsif root.redhat? && root.cdn_configuration.network_sync?
-          {
+          options = {
             client_cert: root.cdn_configuration.ssl_cert,
             client_key: root.cdn_configuration.ssl_key,
             ca_cert: root.cdn_configuration.ssl_ca
           }
         elsif root.custom?
-          {
+          options = {
             client_cert: root.ssl_client_cert&.content,
             client_key: root.ssl_client_key&.content,
             ca_cert: root.ssl_ca_cert&.content
           }
-        else
-          {}
         end
+        append_proxy_cacert(options) if options.key?(:cacert)
+        options
+      end
+
+      def append_proxy_cacert(options)
+        if root.http_proxy&.cacert&.present? && options.key?(:cacert)
+          options[:cacert] += "\n#{root.http_proxy&.cacert}"
+        end
+        options
       end
 
       def lookup_version(href)

data/app/services/katello/pulp3/repository_mirror.rb

@@ -132,6 +132,7 @@ module Katello
         sync_params = repo_service.sync_url_params(options)
         sync_params[:remote] = remote_href
         if repo.yum?
+          sync_params.delete(:skip_types) if sync_params[:skip_types]
           sync_params[:sync_policy] = 'mirror_complete'
         else
           sync_params.delete(:sync_policy)

data/app/services/katello/pulp3/service_common.rb

@@ -43,7 +43,7 @@ module Katello
             response = api.remotes_api.create(remote_file_data)
           end
           #delete is async, but if its not properly deleted, orphan cleanup will take care of it later
-          delete_remote(response.pulp_href)
+          delete_remote(href: response.pulp_href)
         end
       end
 

data/app/services/katello/pulp3/smart_proxy_mirror_repository.rb

@@ -26,7 +26,7 @@ module Katello
           api = repo_type.pulp3_api(smart_proxy)
           version_hrefs = api.repository_versions
           orphan_version_hrefs = api.list_all.collect do |pulp_repo|
-            mirror_repo_versions = api.versions_list_for_repository(pulp_repo.pulp_href, ordering: :_created)
+            mirror_repo_versions = api.versions_list_for_repository(pulp_repo.pulp_href, ordering: ['-pulp_created'])
             version_hrefs = mirror_repo_versions.select { |repo_version| repo_version.number != 0 }.collect { |version| version.pulp_href }
 
             version_hrefs - [pulp_repo.latest_version_href]
@@ -73,9 +73,31 @@ module Katello
             distribution.try(:repository_version).nil?
       end
 
+      def delete_orphan_alternate_content_sources
+        tasks = []
+        known_acs_hrefs = []
+        known_acss = smart_proxy.smart_proxy_alternate_content_sources
+        known_acs_hrefs = known_acss.pluck(:alternate_content_source_href) if known_acss.present?
+
+        file_acs_api = ::Katello::Pulp3::Repository.api(smart_proxy, 'file').alternate_content_source_api
+        yum_acs_api = ::Katello::Pulp3::Repository.api(smart_proxy, 'yum').alternate_content_source_api
+
+        orphan_file_acs_hrefs = file_acs_api.list.results.map(&:pulp_href) - known_acs_hrefs
+        orphan_yum_acs_hrefs = yum_acs_api.list.results.map(&:pulp_href) - known_acs_hrefs
+
+        orphan_file_acs_hrefs.each do |orphan_file_acs_href|
+          tasks << file_acs_api.delete(orphan_file_acs_href)
+        end
+
+        orphan_yum_acs_hrefs.each do |orphan_yum_acs_href|
+          tasks << yum_acs_api.delete(orphan_yum_acs_href)
+        end
+      end
+
       def delete_orphan_remotes
         tasks = []
-        repo_names = Katello::Repository.pluck(:pulp_id)
+        smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+        repo_names = smart_proxy_helper.combined_repos_available_to_capsule.map(&:pulp_id)
         acs_remotes = Katello::SmartProxyAlternateContentSource.pluck(:remote_href)
         pulp3_enabled_repo_types.each do |repo_type|
           api = repo_type.pulp3_api(smart_proxy)

data/app/services/katello/pulp3/task_group.rb

@@ -50,6 +50,10 @@ module Katello
         ::Katello::Pulp3::Api::Core.new(@smart_proxy).task_groups_api
       end
 
+      def tasks_api
+        ::Katello::Pulp3::Api::Core.new(@smart_proxy).tasks_api
+      end
+
       def done?
         task_group_data['all_tasks_dispatched'] == true && IN_PROGRESS_STATES.all? { |state| task_group_data[state] == 0 }
       end
@@ -74,12 +78,25 @@ module Katello
       def error
         return if task_group_data[WAITING] > 0 || task_group_data[RUNNING] > 0
         if task_group_data[FAILED] > 0
-          "#{task_group_data[FAILED]} subtask(s) failed for task group #{@href}."
+          messages = query_task_group_errors(task_group_data)
+          return "#{task_group_data[FAILED]} subtask(s) failed for task group #{@href}.\nErrors:\n #{messages.join("\n")}"
         elsif task_group_data[CANCELLED] > 0
           "#{task_group_data[CANCELLED]} subtask(s) cancelled for task group #{@href}."
         end
       end
 
+      def query_task_group_errors(task_group_data)
+        messages = []
+        tasks_api = core_api.tasks_api
+        tasks_response = core_api.class.fetch_from_list do |page_opts|
+          tasks_api.list(page_opts.merge(task_group: task_group_data['pulp_href'], state__in: [FAILED]))
+        end
+        tasks_response.collect do |result|
+          messages << result.error
+        end
+        return messages
+      end
+
       def core_api
         ::Katello::Pulp3::Api::Core.new(@smart_proxy)
       end