katello 4.2.0.1.rc2 → 4.2.0.1.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27a69c642aae16f1d0c623a4b236b981c1b09c0e78a304555d130a745983ebbc
-  data.tar.gz: aac4bfc71c9bbb798750fbbe27d545aa7a5b4586488598a4fc27fac1c513ddaa
+  metadata.gz: d21cfa77627ae227af66157509f62c5b035a89a46b403d607ba6c70926b7253a
+  data.tar.gz: b9dd69ad43fb90ad1af496ac476e38083e0942ed0f114171c5cfe1b32c075c7b
 SHA512:
-  metadata.gz: 5427524abdae177c66bae610c182e1a58a116ef21198984d9f99b8b03d2615214d8820eca5a7a5cac6fbfea88afa7c8722110529aea86fc8f171f9423143eae2
-  data.tar.gz: 479223ec1f930a5f25adf8c6a97b423a47e6b09871a1cc75c5aaac418b0d6246cb7069d7c11df5ff428f78c2cfc75925d36625a716500bea4e2c7e7723f8f03b
+  metadata.gz: 7e264679f2c596a41ee24e322f0ca2bc521c89b6a18b6d9d245b987d4dae13cd55cbf18483430d590b15c8aa565bbf6e28c5550bc6969a662034e50c2054a214
+  data.tar.gz: 985b102bdd203636c1c84cc038f29fdb7050ea95bb4bd7a7227c4a67d3d3f33a088c7913c75a6a89e5c2f9c8792812101aedd503a67e8ce15fb965a570479b21

data/app/assets/javascripts/katello/hosts/host_and_hostgroup_edit.js

@@ -4,7 +4,7 @@ KT.hosts = {};
 $(document).on('ContentLoad', function(){
     KT.hosts.onKatelloHostEditLoad();
     window.tfm.hosts.registerPluginAttributes("os",
-         ['lifecycle_environment_id', 'content_view_id', 'environment_id', 'content_source_id', 'architecture_id']);
+         ['lifecycle_environment_id', 'content_view_id', 'environment_id', 'content_source_id', 'architecture_id', 'parent_id']);
 
     $("#hostgroup_lifecycle_environment_id").change(KT.hosts.environmentChanged);
     $("#host_lifecycle_environment_id").change(KT.hosts.environmentChanged);
@@ -27,13 +27,15 @@ KT.hosts.fetchContentViews = function () {
     var envId = KT.hosts.getSelectedEnvironment();
     var option;
     var previous_view = KT.hosts.getSelectedContentView();
-
+    var previousInheritViewText = select.find('option:first-child').text();
     select.find('option').remove();
     if (envId) {
         KT.hosts.signalContentViewFetch(true);
         var url = tfm.tools.foremanUrl('/katello/api/v2/content_views/');
         $.get(url, {environment_id: envId, full_result: true}, function (data) {
-            select.append($("<option />"));
+            if ($('#hostgroup_parent_id').length > 0) {
+                select.append($("<option />").text(previousInheritViewText).val(''));
+            }
             $.each(data.results, function(index, view) {
                 option = $("<option />").val(view.id).text(view.name);
                 if (view.id === parseInt(previous_view)) {
@@ -41,6 +43,7 @@ KT.hosts.fetchContentViews = function () {
                 }
                 select.append(option);
             });
+            select.trigger('change');
             KT.hosts.signalContentViewFetch(false);
         });
     }

data/app/controllers/katello/api/v2/content_view_versions_controller.rb

@@ -124,7 +124,8 @@ module Katello
       validate_content(params[:add_content])
       resolve_dependencies = params.fetch(:resolve_dependencies, true)
       task = async_task(::Actions::Katello::ContentView::IncrementalUpdates, @content_view_version_environments, @composite_version_environments,
-                        params[:add_content], resolve_dependencies, hosts, params[:description])
+                        params[:add_content], resolve_dependencies, hosts, params[:description],
+                        Setting[:remote_execution_by_default] && ::Katello.with_remote_execution?)
       respond_for_async :resource => task
     end
 

data/app/helpers/katello/content_view_helper.rb

@@ -1,10 +1,10 @@
 module Katello
   module ContentViewHelper
-    def separated_repo_mapping(repo_mapping)
-      separated_mapping = { :pulp3_yum => {}, :other => {} }
+    def separated_repo_mapping(repo_mapping, use_multicopy_actions)
+      separated_mapping = { :pulp3_yum_multicopy => {}, :other => {} }
       repo_mapping.each do |source_repos, dest_repo|
-        if dest_repo.content_type == "yum" && SmartProxy.pulp_primary.pulp3_support?(dest_repo)
-          separated_mapping[:pulp3_yum][source_repos] = dest_repo
+        if dest_repo.content_type == "yum" && SmartProxy.pulp_primary.pulp3_support?(dest_repo) && use_multicopy_actions
+          separated_mapping[:pulp3_yum_multicopy][source_repos] = dest_repo
         else
           separated_mapping[:other][source_repos] = dest_repo
         end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -58,19 +58,19 @@ module Katello
     end
 
     def fetch_lifecycle_environment(host, options = {})
-      return host.lifecycle_environment if host.lifecycle_environment.present?
+      return host.lifecycle_environment if host.try(:lifecycle_environment_id)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.lifecycle_environment if selected_host_group.present?
     end
 
     def fetch_content_view(host, options = {})
-      return host.content_view if host.content_view.present?
+      return host.content_view if host.try(:content_view_id)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_view if selected_host_group.present?
     end
 
     def fetch_content_source(host, options = {})
-      return host.content_source if host.content_source.present?
+      return host.content_source if host.try(:content_source_id)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_source if selected_host_group.present?
     end
@@ -216,11 +216,15 @@ module Katello
         new_host.operatingsystem.kickstart_repos(new_host).map { |repo| OpenStruct.new(repo) }
       else
         # case 2
-        os_updated_kickstart_options(host)
+        os_updated_kickstart_options
       end
     end
 
-    def os_updated_kickstart_options(host)
+    def fetch_inherited_param(id, entity, parent_value)
+      id.blank? ? parent_value : entity.find(id)
+    end
+
+    def os_updated_kickstart_options(host = nil)
       # this method gets called in 1 place Once you chose a diff os/content source/arch/lifecycle env/cv
       # via the os_selected method.
       # In this case we want it play by the rules of "one of these params" and
@@ -228,19 +232,22 @@ module Katello
       os_selection_params = ["operatingsystem_id", 'content_view_id', 'lifecycle_environment_id',
                              'content_source_id', 'architecture_id']
       view_options = []
+
       host_params = params[:hostgroup] || params[:host]
-      if host_params && os_selection_params.all? { |key| host_params[key].present? }
+      parent = ::Hostgroup.find(host_params[:parent_id]) unless host_params.blank? || host_params[:parent_id].blank?
+      if host_params && (parent || os_selection_params.all? { |key| host_params[key].present? })
         if host.nil?
           host = ::Host.new
         end
-        host.operatingsystem = Operatingsystem.find(host_params[:operatingsystem_id])
-        host.architecture = Architecture.find(host_params[:architecture_id])
+        host.operatingsystem = fetch_inherited_param(host_params[:operatingsystem_id], ::Operatingsystem, parent&.os)
+        host.architecture = fetch_inherited_param(host_params[:architecture_id], ::Architecture, parent&.architecture)
+        lifecycle_env = fetch_inherited_param(host_params[:lifecycle_environment_id], ::Katello::KTEnvironment, parent&.lifecycle_environment)
+        content_view = fetch_inherited_param(host_params[:content_view_id], ::Katello::ContentView, parent&.content_view)
+        content_source = fetch_inherited_param(host_params[:content_source_id], ::SmartProxy, parent&.content_source)
 
-        lifecycle_env = Katello::KTEnvironment.find(host_params[:lifecycle_environment_id])
-        content_view = Katello::ContentView.find(host_params[:content_view_id])
         host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_env.id,
                                                     :content_view_id => content_view.id,
-                                                    :content_source => SmartProxy.find(host_params[:content_source_id]))
+                                                    :content_source => content_source)
         if host.operatingsystem.is_a?(Redhat)
           view_options = host.operatingsystem.kickstart_repos(host).map { |repo| OpenStruct.new(repo) }
         end

data/app/lib/actions/katello/activation_key/destroy.rb

@@ -6,7 +6,7 @@ module Actions
           skip_candlepin = options.fetch(:skip_candlepin, false)
           action_subject(activation_key)
 
-          plan_action(Candlepin::ActivationKey::Destroy, cp_id: activation_key.cp_id) unless skip_candlepin
+          plan_action(Candlepin::ActivationKey::Destroy, cp_id: activation_key.cp_id) if !skip_candlepin && activation_key.cp_id.present?
           plan_self
         end
 

data/app/lib/actions/katello/content_view/incremental_updates.rb

@@ -4,7 +4,8 @@ module Actions
       class IncrementalUpdates < Actions::EntryAction
         include Helpers::Presenter
 
-        def plan(version_environments, composite_version_environments, content, dep_solve, hosts, description)
+        def plan(version_environments, composite_version_environments, content, dep_solve, hosts, description,
+                use_remote_execution = false)
           old_new_version_map = {}
           output_for_version_ids = []
 
@@ -28,12 +29,13 @@ module Actions
               handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description)
             end
 
-            if hosts.any? && !content[:errata_ids].blank?
+            if hosts.any? && !content[:errata_ids].blank? && !use_remote_execution
               errata = ::Katello::Erratum.with_identifiers(content[:errata_ids])
               hosts = hosts.where(:id => ::Katello::Host::ContentFacet.with_applicable_errata(errata).pluck(:host_id))
               plan_action(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, hosts, :errata_ids => content[:errata_ids])
             end
-            plan_self(:version_outputs => output_for_version_ids)
+            plan_self(:version_outputs => output_for_version_ids, :host_ids => hosts.pluck(:id),
+                      :errata_ids => content[:errata_ids], :use_remote_execution => use_remote_execution)
           end
         end
 
@@ -59,6 +61,14 @@ module Actions
         end
 
         def run
+          if input[:errata_ids].present? && input[:host_ids].present? && input[:use_remote_execution]
+            errata_ids = input[:errata_ids].join(',')
+            errata = ::Katello::Erratum.with_identifiers(input[:errata_ids])
+            hosts = ::Host.where(:id => input[:host_ids] &
+                                          ::Katello::Host::ContentFacet.with_applicable_errata(errata).pluck(:host_id))
+            JobInvocationComposer.for_feature('katello_errata_install', hosts, { :errata => errata_ids }).trigger
+          end
+
           output[:changed_content] = input[:version_outputs].map do |version_output|
             {
               :content_view_version => {:id => version_output[:version_id]},

data/app/lib/actions/katello/content_view/publish.rb

@@ -49,13 +49,12 @@ module Actions
             plan_action(ContentView::AddToEnvironment, version, library) unless options[:skip_promotion]
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, version, source_repositories).repository_mapping
             # Split Pulp 3 Yum repos out of the repository_mapping.  Only Pulp 3 RPM plugin has multi repo copy support.
-            separated_repo_map = separated_repo_mapping(repository_mapping)
+            separated_repo_map = separated_repo_mapping(repository_mapping, content_view.solve_dependencies)
 
             if options[:importing]
               handle_import(version, options.slice(:path, :metadata))
-            elsif separated_repo_map[:pulp3_yum].keys.flatten.present? &&
-              SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
-              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
+            elsif separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
+              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
             end
 
             concurrence do

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -55,7 +55,7 @@ module Actions
 
           sequence do
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, new_content_view_version, repos_to_clone).repository_mapping
-            separated_repo_map = separated_repo_mapping(repository_mapping)
+            separated_repo_map = separated_repo_mapping(repository_mapping, true)
 
             repos_to_clone.each do |source_repos|
               plan_action(Repository::CloneToVersion,
@@ -66,8 +66,8 @@ module Actions
             end
 
             concurrence do
-              if separated_repo_map[:pulp3_yum].keys.flatten.present?
-                extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum], old_version)
+              if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
+                extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum_multicopy], old_version)
                 unit_map = pulp3_content_mapping(content)
 
                 unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
@@ -75,7 +75,7 @@ module Actions
                     copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
                                                        dependency_solving: dep_solve).output
                     repos_to_clone.each do |source_repos|
-                      if separated_repo_map[:pulp3_yum].keys.include?(source_repos)
+                      if separated_repo_map[:pulp3_yum_multicopy].keys.include?(source_repos)
                         copy_repos(repository_mapping[source_repos])
                       end
                     end

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

@@ -9,7 +9,7 @@ module Actions
           sequence do
             plan_action(::Actions::Katello::Repository::MultiCloneContents, extended_repo_map,
                         copy_contents: true,
-                        solve_dependencies: content_view.solve_dependencies,
+                        solve_dependencies: true,
                         metadata_generate: !incremental)
           end
         end

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

@@ -20,10 +20,16 @@ module Actions
             _("checking Pulp task status")
           end
         when :suspended
-          if combined_tasks.any?(&:started?)
-            _("waiting for Pulp to finish the task")
+          started_task = combined_tasks.find { |task| task&.started? && !task&.done? }&.pulp_data
+          if started_task
+            name = started_task[:name] || started_task[:description]
+            label = get_task_label(name, started_task[:pulp_href])
+            _("waiting for Pulp to finish the task %s" % label)
           else
-            _("waiting for Pulp to start the task")
+            pending_task = combined_tasks.find { |task| !task&.started? }&.pulp_data
+            name = pending_task[:name] || pending_task[:description]
+            label = get_task_label(name, pending_task[:pulp_href])
+            _("waiting for Pulp to start the task %s" % label) if pending_task
           end
         else
           super
@@ -133,6 +139,13 @@ module Actions
         check_for_errors
         pulp_tasks
       end
+
+      def get_task_label(name, href)
+        name = name.split('.').last if name
+        href = href.split('-').last[0...-1] if href
+        label = "%s (ID: %s)" % [name, href]
+        label
+      end
     end
   end
 end

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

@@ -15,7 +15,7 @@ module Actions
                 if filter_ids.present? || rpm_filenames.present?
                   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)
+                                            rpm_filenames: rpm_filenames, remove_all: true)
                   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
@@ -26,7 +26,7 @@ module Actions
                   source_repositories[1..-1].each do |source_repo|
                     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)
+                                                rpm_filenames: rpm_filenames, remove_all: false)
                   end
                   plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_actions.last.output[:pulp_tasks])
                 end

data/app/lib/katello/qpid/connection.rb

@@ -74,11 +74,13 @@ module Katello
       def initialize(url:, ssl_cert_file:, ssl_key_file:, ssl_ca_file:)
         @url = url
         ssl_domain = ::Qpid::Proton::SSLDomain.new(::Qpid::Proton::SSLDomain::MODE_CLIENT)
+        ssl_domain.peer_authentication(::Qpid::Proton::SSLDomain::VERIFY_PEER_NAME)
         ssl_domain.credentials(ssl_cert_file, ssl_key_file, nil) if ssl_cert_file && ssl_key_file
         ssl_domain.trusted_ca_db(ssl_ca_file) if ssl_ca_file
         @connection_options = {
           ssl_domain: ssl_domain,
-          sasl_allowed_mechs: 'external'
+          sasl_allowed_mechs: 'external',
+          virtual_host: URI.parse(url).host
         }
       end
 

data/app/lib/katello/util/errata.rb

@@ -46,13 +46,18 @@ module Katello
         end
       end
 
-      def filter_errata_by_pulp_href(errata, package_pulp_hrefs)
+      def filter_errata_by_pulp_href(errata, package_pulp_hrefs, source_repo_rpm_filenames)
         return [] if package_pulp_hrefs.empty?
         rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
         rpm_filenames = rpms.map { |rpm| File.basename(rpm.filename) }
+        source_repo_rpm_filenames = source_repo_rpm_filenames.map { |rpm| File.basename(rpm) }
         matching_errata = []
         errata.each do |erratum|
-          if erratum.packages.any? && (erratum.packages.pluck(:filename) - rpm_filenames).empty?
+          # The erratum should be copied if package_pulp_hrefs has all of its packages that are available in the source repo.
+          next if erratum.packages.empty?
+          rpms_in_erratum_and_source_repo = erratum.packages.pluck(:filename) & source_repo_rpm_filenames
+          next if rpms_in_erratum_and_source_repo.empty?
+          if (rpms_in_erratum_and_source_repo - rpm_filenames).empty?
             matching_errata << erratum
           end
         end

data/app/lib/katello/util/pulpcore_content_filters.rb

@@ -8,6 +8,7 @@ module Katello
       def filter_package_groups_by_pulp_href(package_groups, package_pulp_hrefs)
         rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
         package_groups.reject do |package_group|
+          package_group.package_names.empty? ||
           (package_group.package_names - rpms.pluck(:name)).any?
         end
       end

data/app/lib/katello/validators/hostgroup_kickstart_repository_validator.rb

@@ -3,21 +3,34 @@ module Katello
     class HostgroupKickstartRepositoryValidator < ActiveModel::Validator
       def validate(facet)
         return unless facet.kickstart_repository_id
+        if facet.content_source.blank? && facet.hostgroup.content_source.blank?
+          prop = :content_source
+          msg = _("Please select a content source before assigning a kickstart repository")
+        elsif facet.hostgroup.operatingsystem.blank?
+          prop = :base
+          msg = _("Please select an operating system before assigning a kickstart repository")
+        elsif !facet.hostgroup.operatingsystem.is_a?(Redhat)
+          prop = :base
+          msg = _("Kickstart repositories can only be assigned to hosts in the Red Hat family")
+        elsif facet.hostgroup.architecture.blank?
+          prop = :base
+          msg = _("Please select an architecture before assigning a kickstart repository")
+        elsif !content_view_in_env?(facet)
+          prop = :lifecycle_environment
+          msg = _("The selected/Inherited Content View is not available for this Lifecycle Environment")
+        elsif !facet.hostgroup.matching_kickstart_repository?(facet)
+          prop = :kickstart_repository
+          msg = _("The selected kickstart repository is not part of the assigned content view, " \
+                  "lifecycle environment, content source, operating system, and architecture")
+        end
+        facet.hostgroup.errors.add(prop, msg) if msg
+      end
 
-        msg = if facet.content_source.blank?
-                _("Please select a content source before assigning a kickstart repository")
-              elsif facet.hostgroup.operatingsystem.blank?
-                _("Please select an operating system before assigning a kickstart repository")
-              elsif !facet.hostgroup.operatingsystem.is_a?(Redhat)
-                _("Kickstart repositories can only be assigned to hosts in the Red Hat family")
-              elsif facet.hostgroup.architecture.blank?
-                _("Please select an architecture before assigning a kickstart repository")
-              elsif !facet.hostgroup.matching_kickstart_repository?(facet)
-                _("The selected kickstart repository is not part of the assigned content view, lifecycle environment,
-                  content source, operating system, and architecture")
-              end
-
-        facet.errors.add(:base, msg) if msg
+      def content_view_in_env?(facet)
+        env = facet.lifecycle_environment || facet.hostgroup.lifecycle_environment
+        cv = facet.content_view || facet.hostgroup.content_view
+        return true if env.blank? || cv.blank?
+        env.content_views.include?(cv)
       end
     end
   end

data/app/models/katello/concerns/hostgroup_extensions.rb

@@ -39,7 +39,7 @@ module Katello
           self.medium = nil
         end
 
-        unless matching_kickstart_repository?(content_facet)
+        if content_facet&.kickstart_repository_id && !matching_kickstart_repository?(content_facet)
           if (equivalent = equivalent_kickstart_repository)
             self.content_facet.kickstart_repository_id = equivalent[:id]
           end
@@ -92,10 +92,10 @@ module Katello
 
       def equivalent_kickstart_repository
         return unless operatingsystem &&
-                      kickstart_repository &&
+                      content_facet.kickstart_repository &&
                       operatingsystem.respond_to?(:kickstart_repos)
-        ks_repos = operatingsystem.kickstart_repos(self)
-        ks_repos.find { |repo| repo[:name] == kickstart_repository.label }
+        ks_repos = operatingsystem.kickstart_repos(self, content_facet: content_facet)
+        ks_repos.find { |repo| repo[:name] == content_facet.kickstart_repository.label }
       end
 
       def matching_kickstart_repository?(content_facet)

data/app/models/katello/concerns/redhat_extensions.rb

@@ -52,8 +52,9 @@ module Katello
       def kickstart_repos(host, content_facet: nil)
         distros = distribution_repositories(host, content_facet: content_facet).where(distribution_bootable: true)
         content_facet ||= host.content_facet
-        if distros && content_facet&.content_source
-          distros.map { |distro| distro.to_hash(content_facet.content_source) }
+        cs = content_facet&.content_source || host.try(:content_source)
+        if distros && cs
+          distros.map { |distro| distro.to_hash(cs) }
         else
           []
         end

data/app/overrides/add_activation_keys_input.rb

@@ -10,7 +10,7 @@ Deface::Override.new(:virtual_path => "hostgroups/_form",
 
 Deface::Override.new(:virtual_path => "hostgroups/_form",
                      :name => "hostgroups_update_environments_select",
-                     :insert_before => 'erb[loud]:contains("hostgroup_puppet_environment_field")',
+                     :insert_before => 'erb[loud]:contains("compute_resource_id")',
                      :partial => 'overrides/activation_keys/host_environment_select')
 
 Deface::Override.new(:virtual_path => "common/os_selection/_operatingsystem",

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

@@ -13,30 +13,30 @@ module Katello
       end
 
       # Package type is now an integer:
-      # 1. default
-      # 2. optional
-      # 3. conditional
-      # 4. mandatory
-      # 5. unknown
+      # 0. default
+      # 1. optional
+      # 2. conditional
+      # 3. mandatory
+      # 4. unknown
       # https://github.com/rpm-software-management/libcomps/blob/01a4759894cccff64d2561614a58281adf5ce859/libcomps/src/comps_docpackage.h#L36
       def default_package_names
-        package_names_of_type(1)
+        package_names_of_type(0)
       end
 
       def optional_package_names
-        package_names_of_type(2)
+        package_names_of_type(1)
       end
 
       def conditional_package_names
-        package_names_of_type(3)
+        package_names_of_type(2)
       end
 
       def mandatory_package_names
-        package_names_of_type(4)
+        package_names_of_type(3)
       end
 
       def unknown_package_names
-        package_names_of_type(5)
+        package_names_of_type(4)
       end
 
       def package_names_of_type(type)

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

@@ -191,21 +191,17 @@ module Katello
           tasks
         end
 
-        def copy_units(source_repository, content_unit_hrefs, dependency_solving)
+        def copy_units(source_repository, content_unit_hrefs, remove_all)
+          remove_all = true if remove_all.nil?
           tasks = []
 
           if content_unit_hrefs.sort!.any?
-            data = PulpRpmClient::Copy.new
-            data.config = [{
-              source_repo_version: source_repository.version_href,
-              dest_repo: repository_reference.repository_href,
-              dest_base_version: 0,
-              content: content_unit_hrefs
-            }]
-            data.dependency_solving = dependency_solving
-            package_env_hrefs = packageenvironments({ :repository_version => source_repository.version_href }).map(&:pulp_href).sort
-            tasks << api.copy_api.copy_content(data)
-            tasks << add_content(package_env_hrefs) unless package_env_hrefs.empty?
+            content_unit_hrefs += packageenvironments({ :repository_version => source_repository.version_href }).map(&:pulp_href).sort
+            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
@@ -319,11 +315,6 @@ module Katello
             dest_repo_map[:content_unit_hrefs] = content_unit_hrefs.uniq.sort
           end
 
-          errata_to_include = errata_to_include_from_map(repo_id_map)
-          repo_id_map.each do |_, dest_repo_map|
-            dest_repo_map[:content_unit_hrefs] |= errata_to_include.flat_map { |erratum| erratum.repository_errata.pluck(:erratum_pulp3_href) }
-          end
-
           dependency_solving = options[:solve_dependencies] || false
 
           multi_copy_units(repo_id_map, dependency_solving)
@@ -358,17 +349,10 @@ module Katello
           blacklist_ids += modular_packages(source_repository, exclusion_modular_filters) unless exclusion_modular_filters.empty?
           content_unit_hrefs = whitelist_ids - blacklist_ids
           if content_unit_hrefs.any?
-            content_unit_hrefs += additional_content_hrefs(source_repository, content_unit_hrefs, true)
+            content_unit_hrefs += additional_content_hrefs(source_repository, content_unit_hrefs)
           end
           content_unit_hrefs += source_repository.srpms.pluck(:pulp_id)
-          dependency_solving = options[:solve_dependencies] || false
-          copy_units(source_repository, content_unit_hrefs.uniq, dependency_solving)
-        end
-
-        def errata_to_include_from_map(repo_id_map)
-          all_errata = ::Katello::Erratum.in_repositories(repo_id_map.keys.flatten.uniq)
-          all_content_units = repo_id_map.values.pluck(:content_unit_hrefs).flatten.uniq
-          filter_errata_by_pulp_href(all_errata, all_content_units)
+          copy_units(source_repository, content_unit_hrefs.uniq, options[:remove_all])
         end
 
         def modular_packages(source_repository, filters)
@@ -379,14 +363,13 @@ module Katello
           list_ids
         end
 
-        def additional_content_hrefs(source_repository, content_unit_hrefs, copy_errata = false)
+        def additional_content_hrefs(source_repository, content_unit_hrefs)
           repo_service = source_repository.backend_service(SmartProxy.pulp_primary)
           options = { :repository_version => source_repository.version_href }
 
-          if copy_errata
-            errata_to_include = filter_errata_by_pulp_href(source_repository.errata, content_unit_hrefs)
-            content_unit_hrefs += errata_to_include.collect { |erratum| erratum.repository_errata.pluck(:erratum_pulp3_href) }.flatten
-          end
+          errata_to_include = filter_errata_by_pulp_href(source_repository.errata, content_unit_hrefs,
+                                                         source_repository.rpms.pluck(:filename))
+          content_unit_hrefs += errata_to_include.collect { |erratum| erratum.repository_errata.pluck(:erratum_pulp3_href) }.flatten
 
           package_groups_to_include = filter_package_groups_by_pulp_href(source_repository.package_groups, content_unit_hrefs)
           content_unit_hrefs += package_groups_to_include.pluck(:pulp_id)

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

@@ -122,6 +122,7 @@ module Katello
             remote_partial_update
           else
             create_remote
+            return nil #return nil, as create isn't async
           end
         end
       end
@@ -454,9 +455,14 @@ module Katello
         end
       end
 
-      def add_content(content_unit_href)
+      def add_content(content_unit_href, remove_all_units = false)
         content_unit_href = [content_unit_href] unless content_unit_href.is_a?(Array)
-        api.repositories_api.modify(repository_reference.repository_href, add_content_units: content_unit_href)
+        if remove_all_units
+          api.repositories_api.modify(repository_reference.repository_href, remove_content_units: ['*'])
+          api.repositories_api.modify(repository_reference.repository_href, add_content_units: content_unit_href)
+        else
+          api.repositories_api.modify(repository_reference.repository_href, add_content_units: content_unit_href)
+        end
       end
 
       def add_content_for_repo(repository_href, content_unit_href)

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

@@ -38,6 +38,7 @@ module Katello
 
       #needed for serialization in dynflow
 
+      attr_reader :pulp_data
       delegate :[], :key?, :dig, :to_hash, :to => :task_data
 
       def initialize(smart_proxy, data)
@@ -83,7 +84,7 @@ module Katello
       end
 
       def done?
-        task_data[:finish_time] || FINISHED_STATES.include?(task_data[:state])
+        task_data[:finished_at] || FINISHED_STATES.include?(task_data[:state])
       end
 
       def progress_reports
@@ -100,7 +101,7 @@ module Katello
       end
 
       def started?
-        task_data[:start_time]
+        task_data[:started_at]
       end
 
       def error

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

@@ -15,6 +15,7 @@ module Katello
       delegate :dig, :to => :task_group_data
 
       attr_accessor :href
+      attr_reader :pulp_data
 
       # A call report Looks like:  {"task":"/pulp/api/v3/tasks/5/"}
       #{

data/app/views/overrides/activation_keys/_host_environment_select.html.erb

@@ -37,9 +37,9 @@ end %>
 
 <%= field(f, cs_select_attr, {:label => _("Content Source")}) do
   if using_hostgroups_page?
-    select_tag cs_select_id, content_source_options(@hostgroup, :selected_host_group => @hostgroup.hostgroup, :include_blank => blank_or_inherit_with_id(f, :content_source)), :data => {"spinner_path" => spinner_path},
-               :class => 'form-control',  :name => cs_select_name, include_blank: true
+    select_tag cs_select_id, content_source_options(@hostgroup, :include_blank => blank_or_inherit_with_id(f, :content_source)), :data => {"spinner_path" => spinner_path},
+               :class => 'form-control',  :name => cs_select_name
   else
-    select_tag cs_select_id, content_source_options(@host, :selected_host_group => @host.hostgroup, :include_blank => blank_or_inherit_with_id(f, :content_source)), :data => {"spinner_path" => spinner_path}, :class => 'form-control',  :name => cs_select_name, include_blank: true
+    select_tag cs_select_id, content_source_options(@host, :selected_host_group => @hostgroup || @host.hostgroup, :include_blank => blank_or_inherit_with_id(f, :content_source)), :data => {"spinner_path" => spinner_path}, :class => 'form-control',  :name => cs_select_name
   end
 end %>

data/engines/bastion_katello/app/assets/javascripts/bastion_katello/content-hosts/bulk/views/content-hosts-bulk-errata-modal.html

@@ -101,7 +101,7 @@
              <td bst-table-cell>{{ erratum.title }}</td>
              <td class="small" bst-table-cell>{{ erratum.issued }}</td>
              <td class="small" bst-table-cell class="number-cell">
-               <a href="{{ '/content_hosts?search=installable_errata%3D' + erratum.errata_id }}">
+               <a target="_blank" href="{{ '/content_hosts?search=installable_errata%3D' + erratum.errata_id }}">
                 <span> {{ erratum.affected_hosts_count }} </span>
                  <span class="fa fa-external-link"/>
                </a>

data/engines/bastion_katello/app/assets/javascripts/bastion_katello/errata/apply-errata.controller.js

@@ -10,14 +10,13 @@
  * @requires ContentViewVersion
  * @requires CurrentOrganization
  * @requires Notification
- * @requires BastionConfig
  *
  * @description
  *   Display confirmation screen and apply Errata.
  */
 angular.module('Bastion.errata').controller('ApplyErrataController',
-    ['$scope', '$window', 'translate', 'IncrementalUpdate', 'HostBulkAction', 'ContentViewVersion', 'CurrentOrganization', 'Notification', 'BastionConfig',
-        function ($scope, $window, translate, IncrementalUpdate, HostBulkAction, ContentViewVersion, CurrentOrganization, Notification, BastionConfig) {
+    ['$scope', '$window', 'translate', 'IncrementalUpdate', 'HostBulkAction', 'ContentViewVersion', 'CurrentOrganization', 'Notification',
+        function ($scope, $window, translate, IncrementalUpdate, HostBulkAction, ContentViewVersion, CurrentOrganization, Notification) {
             var applyErrata, incrementalUpdate;
 
             function transitionToTask(task) {
@@ -32,8 +31,6 @@ angular.module('Bastion.errata').controller('ApplyErrataController',
 
             $scope.applyingErrata = false;
 
-            $scope.remoteExecutionPresent = BastionConfig.remoteExecutionPresent;
-            $scope.remoteExecutionByDefault = BastionConfig.remoteExecutionByDefault;
             $scope.errataActionFormValues = {
                 authenticityToken: $window.AUTH_TOKEN.replace(/"/g, ''),
                 errata: IncrementalUpdate.getErrataIds().join(','),
@@ -134,15 +131,11 @@ angular.module('Bastion.errata').controller('ApplyErrataController',
             });
 
             $scope.confirmApply = function() {
-                if ($scope.remoteExecutionPresent && $scope.remoteExecutionByDefault) {
-                    angular.element('#errataActionForm').submit();
+                $scope.applyingErrata = true;
+                if ($scope.updates.length === 0) {
+                    applyErrata();
                 } else {
-                    $scope.applyingErrata = true;
-                    if ($scope.updates.length === 0) {
-                        applyErrata();
-                    } else {
-                        incrementalUpdate();
-                    }
+                    incrementalUpdate();
                 }
             };
 

data/lib/katello/version.rb

@@ -1,3 +1,3 @@
 module Katello
-  VERSION = "4.2.0.1.rc2".freeze
+  VERSION = "4.2.0.1.rc3".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katello
 version: !ruby/object:Gem::Version
-  version: 4.2.0.1.rc2
+  version: 4.2.0.1.rc3
 platform: ruby
 authors:
 - N/A
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-02 00:00:00.000000000 Z
+date: 2021-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -115,6 +115,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -122,6 +125,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: activerecord-import
   requirement: !ruby/object:Gem::Requirement