katello 4.4.2.2 → 4.5.0.rc1

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -205,9 +205,7 @@ module Katello
         return [] unless new_host.operatingsystem.is_a?(Redhat)
 
         if (host.is_a? ::Hostgroup)
-          new_host.content_facet = ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => host.inherited_lifecycle_environment_id,
-                                                          :content_view_id => host.inherited_content_view_id,
-                                                          :content_source_id => host.inherited_content_source_id)
+          new_host.content_facet = hostgroup_content_facet(host, param_host)
         elsif host.content_facet.present?
           new_host.content_facet = ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => host.content_facet.lifecycle_environment_id,
                                                           :content_view_id => host.content_facet.content_view_id,
@@ -270,5 +268,25 @@ module Katello
     def hosts_change_content_source
       [{ action: [_('Change Content Source'), '/change_host_content_source', false], priority: 100 }]
     end
+
+    private
+
+    def hostgroup_content_facet(hostgroup, param_host)
+      lifecycle_environment_id = hostgroup.inherited_lifecycle_environment_id
+      content_view_id = hostgroup.inherited_content_view_id
+      content_source_id = hostgroup.inherited_content_source_id
+      if param_host.lifecycle_environment_id && (hostgroup.inherited_lifecycle_environment_id != param_host.lifecycle_environment_id)
+        lifecycle_environment_id = param_host.lifecycle_environment_id
+      end
+      if param_host.content_view_id && (hostgroup.inherited_content_view_id != param_host.content_view_id)
+        content_view_id = param_host.content_view_id
+      end
+      if param_host.content_source_id && (hostgroup.inherited_content_source_id != param_host.content_source_id)
+        content_source_id = param_host.content_source_id
+      end
+      ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_environment_id,
+                                        :content_view_id => content_view_id,
+                                        :content_source_id => content_source_id)
+    end
   end
 end

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

@@ -0,0 +1,24 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Create < Actions::EntryAction
+        def plan(acs, smart_proxies)
+          acs.save!
+          action_subject(acs)
+          smart_proxies = smart_proxies.uniq
+          concurrence do
+            smart_proxies.each do |smart_proxy|
+              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
+                          acs, smart_proxy)
+            end
+          end
+        end
+
+        def humanized_name
+          _("Create Alternate Content Source")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Destroy < Actions::EntryAction
+        def plan(acs)
+          action_subject(acs)
+          sequence do
+            acs.smart_proxies.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
+                          acs, smart_proxy)
+            end
+            plan_self(:acs_id => acs.id)
+          end
+        end
+
+        def finalize
+          acs = ::Katello::AlternateContentSource.find_by(id: input[:acs_id])
+          acs.destroy
+        end
+
+        def humanized_name
+          _("Destroy Alternate Content Source")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Update < Actions::EntryAction
+        # smart_proxies ALWAYS represents the smart proxies to remain associated
+        # after the action runs.  If smart_proxies == [], there will be none afterwards.
+        def plan(acs, smart_proxies, acs_params)
+          action_subject(acs)
+          acs.update!(acs_params)
+
+          smart_proxies = smart_proxies.uniq
+          smart_proxies_to_add = smart_proxies - acs.smart_proxies
+          smart_proxies_to_delete = acs.smart_proxies - smart_proxies
+          smart_proxies_to_update = smart_proxies & acs.smart_proxies
+
+          concurrence do
+            smart_proxies_to_add&.each do |smart_proxy|
+              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
+                          acs, smart_proxy)
+            end
+
+            smart_proxies_to_delete&.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
+                          acs, smart_proxy)
+            end
+
+            smart_proxies_to_update&.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Update,
+                          acs, smart_proxy)
+            end
+          end
+        end
+
+        def humanized_name
+          _("Update Alternate Content Source")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/cdn_configuration/update.rb

@@ -5,7 +5,7 @@ module Actions
         def plan(cdn_configuration, options)
           cdn_configuration.update!(options)
 
-          if cdn_configuration.upstream_server?
+          if cdn_configuration.network_sync?
             resource = ::Katello::Resources::CDN::CdnResource.create(cdn_configuration: cdn_configuration)
             resource.validate!
             keypair = resource.debug_certificate
@@ -20,7 +20,7 @@ module Actions
           roots.each do |root|
             full_path = if cdn_configuration.redhat_cdn?
                           root.product.repo_url(root.library_instance.generate_content_path)
-                        elsif cdn_configuration.upstream_server?
+                        elsif cdn_configuration.network_sync?
                           resource.repository_url(content_label: root.content.label)
                         end
             plan_action(::Actions::Katello::Repository::Update, root, url: full_path)

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

@@ -25,7 +25,8 @@ module Actions
         end
 
         def finalize
-          content_view = ::Katello::ContentView.find(input[:content_view][:id])
+          content_view = ::Katello::ContentView.where(id: input[:content_view][:id]).first
+          return if content_view.blank?
           content_view.content_view_repositories.each(&:destroy)
           content_view.destroy!
         end

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

@@ -13,6 +13,11 @@ module Actions
             concurrence do
               version_environments.each do |version_environment|
                 version = version_environment[:content_view_version]
+                if version.content_view.generated?
+                  fail _("Cannot perform an incremental update on a Generated Content View Version (%{name} version version %{version}") %
+                    {:name => version.content_view.name, :version => version.version}
+                end
+
                 if version.content_view.composite?
                   fail _("Cannot perform an incremental update on a Composite Content View Version (%{name} version version %{version}") %
                     {:name => version.content_view.name, :version => version.version}
@@ -53,9 +58,8 @@ module Actions
 
               action = plan_action(ContentViewVersion::IncrementalUpdate, composite_version, environments,
                                    :new_components => new_components, :description => description)
-              unless SmartProxy.pulp_primary.pulp3_repository_type_support?("yum")
-                output_for_version_ids << {:version_id => action.new_content_view_version.id, :output => action.output}
-              end
+
+              output_for_version_ids << {:version_id => action.new_content_view_version_id, :output => action.output}
             end
           end
         end

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

@@ -90,19 +90,13 @@ module Actions
         end
 
         def run
-          metadata = {
-            description: _("Auto Publish - Triggered by '%s'") % input[:content_view_version_name],
-            triggered_by: input[:content_view_version_id]
-          }
-          input[:auto_publish_composite_ids].each do |composite_id|
-            ::Katello::EventQueue.push_event(::Katello::Events::AutoPublishCompositeView::EVENT_TYPE, composite_id) do |attrs|
-              attrs[:metadata] = metadata
-            end
-          end
+          version = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          version.auto_publish_composites!
 
           output[:content_view_id] = input[:content_view_id]
           output[:content_view_version_id] = input[:content_view_version_id]
           output[:skip_promotion] = input[:skip_promotion]
+          output[:history_id] = input[:history_id]
         end
 
         def rescue_strategy_for_self
@@ -142,6 +136,10 @@ module Actions
           input['content_view_version_name']
         end
 
+        def history_id
+          input['history_id']
+        end
+
         private
 
         def include_other_components(override_components, content_view)

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

@@ -2,14 +2,14 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateProducts < Actions::Base
-        def plan(organization:, metadata:)
+        def plan(import:)
           helper = ::Katello::Pulp3::ContentViewVersion::ImportableProducts.
-                      new(organization: organization,
-                          metadata: metadata)
+                      new(organization: import.organization,
+                          metadata_products: import.metadata_map.products)
           helper.generate!
           concurrence do
             helper.creatable.each do |product|
-              plan_action(::Actions::Katello::Product::Create, product[:product], organization)
+              plan_action(::Actions::Katello::Product::Create, product[:product], import.organization)
             end
             helper.updatable.each do |product|
               plan_action(::Actions::Katello::Product::Update, product[:product], product[:options])

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

@@ -2,11 +2,13 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRedhatRepositories < Actions::Base
-        def plan(organization:, metadata:)
-          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.
-                      new(organization: organization,
-                      metadata: metadata, redhat: true)
+        def plan(import:)
+          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
+            organization: import.organization,
+            metadata_repositories: import.metadata_map.repositories.select { |r| r.redhat }
+          )
           helper.generate!
+
           sequence do
             helper.creatable.each do |root|
               plan_action(::Actions::Katello::RepositorySet::EnableRepository, root[:product], root[:content], root[:substitutions])

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

@@ -2,11 +2,13 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRepositories < Actions::Base
-        def plan(organization:, metadata:)
-          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.
-                      new(organization: organization,
-                          metadata: metadata)
+        def plan(import:)
+          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
+            organization: import.organization,
+            metadata_repositories: import.metadata_map.repositories.select { |r| !r.redhat }
+          )
           helper.generate!
+
           sequence do
             helper.creatable.each do |root|
               plan_action(::Actions::Katello::Repository::CreateRoot, root[:repository])

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

@@ -2,38 +2,41 @@ module Actions
   module Katello
     module ContentViewVersion
       class Import < Actions::EntryAction
-        def plan(organization:, path:, metadata:, library: false)
-          fail _("Content view not provided in the metadata") if metadata[:content_view].blank?
-          content_view = ::Katello::Pulp3::ContentViewVersion::Import.
-                                find_or_create_import_view(organization: organization,
-                                                           metadata: metadata[:content_view],
-                                                           library: library)
-          content_view.check_ready_to_import!
-          ::Katello::Pulp3::ContentViewVersion::Import.check!(content_view: content_view,
-                                                              metadata: metadata,
-                                                              path: path,
-                                                              smart_proxy: SmartProxy.pulp_primary!)
+        def plan(organization:, path:, metadata:)
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: metadata)
 
-          major = metadata[:content_view_version][:major]
-          minor = metadata[:content_view_version][:minor]
-          description = metadata[:content_view_version][:description]
+          import = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: organization,
+            metadata_map: metadata_map,
+            path: path,
+            smart_proxy: SmartProxy.pulp_primary!
+          )
+
+          import.check!
 
           gpg_helper = ::Katello::Pulp3::ContentViewVersion::ImportGpgKeys.
                           new(organization: organization,
-                              metadata: metadata)
+                              metadata_gpg_keys: metadata_map.gpg_keys)
           gpg_helper.import!
 
           sequence do
-            plan_action(AutoCreateProducts, organization: content_view.organization, metadata: metadata)
-            plan_action(AutoCreateRepositories, organization: content_view.organization, metadata: metadata)
-            plan_action(AutoCreateRedhatRepositories, organization: content_view.organization, metadata: metadata)
-            plan_action(ResetContentViewRepositoriesFromMetadata, content_view: content_view, metadata: metadata)
-            plan_action(::Actions::Katello::ContentView::Publish, content_view, description,
+            plan_action(AutoCreateProducts, import: import)
+            plan_action(AutoCreateRepositories, import: import)
+            plan_action(AutoCreateRedhatRepositories, import: import)
+            plan_action(ResetContentViewRepositoriesFromMetadata, import: import)
+            plan_action(::Actions::Katello::ContentView::Publish, import.content_view, metadata_map.content_view_version.description,
                           path: path,
                           metadata: metadata,
                           importing: true,
-                          major: major,
-                          minor: minor)
+                          major: metadata_map.content_view_version.major,
+                          minor: metadata_map.content_view_version.minor)
+            plan_self(content_view_id: import.content_view.id)
+          end
+        end
+
+        def finalize
+          if task.execution_plan.run_steps.any? { |s| s.action_class == ::Actions::Pulp3::ContentViewVersion::CreateImport && s.state != :success }
+            ::Katello::EventQueue.push_event(::Katello::Events::DeleteLatestContentViewVersion::EVENT_TYPE, input[:content_view_id])
           end
         end
 

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

@@ -5,7 +5,6 @@ module Actions
         def plan(organization, path:, metadata:)
           action_subject(organization)
           plan_action(::Actions::Katello::ContentViewVersion::Import, organization: organization,
-                                                                      library: true,
                                                                       path: path,
                                                                       metadata: metadata)
         end

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

@@ -0,0 +1,21 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class ImportRepository < Actions::EntryAction
+        def plan(organization, path:, metadata:)
+          action_subject(organization)
+          sequence do
+            plan_action(::Actions::Katello::ContentViewVersion::Import,
+                                            organization: organization,
+                                            path: path,
+                                            metadata: metadata)
+          end
+        end
+
+        def humanized_name
+          _("Import Repository")
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Actions
     module ContentViewVersion
       class IncrementalUpdate < Actions::EntryAction
         include ::Katello::ContentViewHelper
-        attr_accessor :new_content_view_version
+        attr_accessor :new_content_view_version, :new_content_view_version_id
 
         HUMANIZED_TYPES = {
           ::Katello::Erratum::CONTENT_TYPE => "Errata",
@@ -18,6 +18,7 @@ module Actions
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
         def plan(old_version, environments, options = {})
           dep_solve = options.fetch(:resolve_dependencies, true)
           description = options.fetch(:description, '')
@@ -31,85 +32,93 @@ module Actions
           validate_environments(environments, old_version)
 
           new_minor = old_version.content_view.versions.where(:major => old_version.major).maximum(:minor) + 1
-          if SmartProxy.pulp_primary.pulp3_repository_type_support?("yum") && is_composite
+
+          if is_composite
             sequence do
               publish_action = plan_action(::Actions::Katello::ContentView::Publish, old_version.content_view, description,
                           :major => old_version.major, :minor => new_minor,
                           :override_components => new_components, :skip_promotion => true)
+
+              self.new_content_view_version_id = publish_action.content_view_version_id
+              plan_self(:is_composite => true, :content_view_id => old_version.content_view.id,
+                        :new_content_view_version_id => publish_action.content_view_version_id,
+                        :environment_ids => environments.map(&:id), :user_id => ::User.current.id,
+                        :history_id => publish_action.history_id,
+                        :old_version => old_version.id)
+
               if old_version.environments.present?
                 plan_action(::Actions::Katello::ContentView::Promote, publish_action.version,
                             old_version.environments, true, description)
               end
             end
-            return
-          end
-
-          self.new_content_view_version = old_version.content_view.create_new_version(old_version.major, new_minor, all_components)
-          history = ::Katello::ContentViewHistory.create!(:content_view_version => new_content_view_version, :user => ::User.current.login,
-                                                          :action => ::Katello::ContentViewHistory.actions[:publish],
-                                                          :status => ::Katello::ContentViewHistory::IN_PROGRESS, :task => self.task,
-                                                          :notes => description)
+          else
+            self.new_content_view_version = old_version.content_view.create_new_version(old_version.major, new_minor, all_components)
+            history = ::Katello::ContentViewHistory.create!(:content_view_version => new_content_view_version, :user => ::User.current.login,
+                                                            :action => ::Katello::ContentViewHistory.actions[:publish],
+                                                            :status => ::Katello::ContentViewHistory::IN_PROGRESS, :task => self.task,
+                                                            :notes => description)
 
-          copy_action_outputs = []
-          repos_to_clone = repos_to_copy(old_version, new_components)
+            copy_action_outputs = []
+            repos_to_clone = repos_to_copy(old_version, new_components)
 
-          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, true)
-
-            repos_to_clone.each do |source_repos|
-              plan_action(Repository::CloneToVersion,
-                          source_repos,
-                          new_content_view_version,
-                          repository_mapping[source_repos],
-                          incremental: true)
-            end
+            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, true)
+
+              repos_to_clone.each do |source_repos|
+                plan_action(Repository::CloneToVersion,
+                            source_repos,
+                            new_content_view_version,
+                            repository_mapping[source_repos],
+                            incremental: true)
+              end
 
-            concurrence do
-              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?
-                  sequence do
-                    # Pre-copy content if dest_repo is a soft copy of its library instance.
-                    # Don't use extended_repo_mapping because the source repositories are library instances.
-                    # We want the old CV snapshot repositories here so as to not pull in excess new content.
-                    separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
-                      if dest_repo.soft_copy_of_library?
-                        source_repos.each do |source_repo|
-                          # remove_all flag is set to cover the case of incrementally updating more than once with different content.
-                          # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
-                          plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+              concurrence do
+                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?
+                    sequence do
+                      # Pre-copy content if dest_repo is a soft copy of its library instance.
+                      # Don't use extended_repo_mapping because the source repositories are library instances.
+                      # We want the old CV snapshot repositories here so as to not pull in excess new content.
+                      separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
+                        if dest_repo.soft_copy_of_library?
+                          source_repos.each do |source_repo|
+                            # remove_all flag is set to cover the case of incrementally updating more than once with different content.
+                            # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
+                            plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+                          end
                         end
                       end
-                    end
-                    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_multicopy].keys.include?(source_repos)
-                        copy_repos(repository_mapping[source_repos])
+                      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_multicopy].keys.include?(source_repos)
+                          copy_repos(repository_mapping[source_repos])
+                        end
                       end
                     end
                   end
                 end
-              end
 
-              if separated_repo_map[:other].keys.flatten.present?
-                repos_to_clone.each do |source_repos|
-                  if separated_repo_map[:other].keys.include?(source_repos)
-                    copy_repos(repository_mapping[source_repos])
+                if separated_repo_map[:other].keys.flatten.present?
+                  repos_to_clone.each do |source_repos|
+                    if separated_repo_map[:other].keys.include?(source_repos)
+                      copy_repos(repository_mapping[source_repos])
+                    end
                   end
                 end
               end
-            end
 
-            plan_self(:content_view_id => old_version.content_view.id,
-                      :new_content_view_version_id => self.new_content_view_version.id,
-                      :environment_ids => environments.map(&:id), :user_id => ::User.current.id,
-                      :history_id => history.id, :copy_action_outputs => copy_action_outputs,
-                      :old_version => old_version.id)
-            promote(new_content_view_version, environments)
+              plan_self(:content_view_id => old_version.content_view.id,
+                        :new_content_view_version_id => self.new_content_view_version.id,
+                        :environment_ids => environments.map(&:id), :user_id => ::User.current.id,
+                        :history_id => history.id, :copy_action_outputs => copy_action_outputs,
+                        :old_version => old_version.id)
+              promote(new_content_view_version, environments)
+            end
           end
         end
 
@@ -203,7 +212,7 @@ module Actions
           end
         end
 
-        def run # rubocop:disable Metrics/CyclomaticComplexity
+        def run
           content = { ::Katello::Erratum::CONTENT_TYPE => [],
                       ::Katello::Rpm::CONTENT_TYPE => [],
                       ::Katello::ModuleStream::CONTENT_TYPE => [],
@@ -213,44 +222,23 @@ module Actions
           base_repos = ::Katello::ContentViewVersion.find(input[:old_version]).repositories
           new_repos = ::Katello::ContentViewVersion.find(input[:new_content_view_version_id]).repositories
 
-          if input[:copy_action_outputs].present? && input[:copy_action_outputs].last[:pulp_tasks].present?
-            if input[:copy_action_outputs].last[:pulp_tasks].last[:pulp_href]&.include?("/pulp/api/v3/")
-              new_repos.each do |new_repo|
-                matched_old_repo = base_repos.where(root_id: new_repo.root_id).first
+          if input[:is_composite] || input[:copy_action_outputs].present? && input[:copy_action_outputs].last[:pulp_tasks].present?
+            new_repos.each do |new_repo|
+              matched_old_repo = base_repos.where(root_id: new_repo.root_id).first
 
-                new_errata = new_repo.errata - matched_old_repo.errata
-                new_module_streams = new_repo.module_streams - matched_old_repo.module_streams
-                new_rpms = new_repo.rpms - matched_old_repo.rpms
+              new_errata = new_repo.errata - (matched_old_repo&.errata || [])
+              new_module_streams = new_repo.module_streams - (matched_old_repo&.module_streams || [])
+              new_rpms = new_repo.rpms - (matched_old_repo&.rpms || [])
 
-                new_errata.each do |erratum|
-                  content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
-                end
-                new_module_streams.each do |module_stream|
-                  content[::Katello::ModuleStream::CONTENT_TYPE] <<
-                    "#{module_stream.name}:#{module_stream.stream}:#{module_stream.version}"
-                end
-                new_rpms.each do |rpm|
-                  content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
-                end
+              new_errata.each do |erratum|
+                content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
               end
-            else
-              input[:copy_action_outputs].each do |copy_output|
-                copy_output[:pulp_tasks].each do |pulp_task|
-                  pulp_task[:result][:units_successful].each do |unit|
-                    type = unit['type_id']
-                    unit = unit['unit_key']
-                    case type
-                    when ::Katello::Erratum::CONTENT_TYPE
-                      content[::Katello::Erratum::CONTENT_TYPE] << unit['id']
-                    when ::Katello::ModuleStream::CONTENT_TYPE
-                      content[::Katello::ModuleStream::CONTENT_TYPE] << "#{unit['name']}:#{unit['stream']}:#{unit['version']}"
-                    when ::Katello::Rpm::CONTENT_TYPE
-                      content[::Katello::Rpm::CONTENT_TYPE] << ::Katello::Util::Package.build_nvra(unit)
-                    when ::Katello::Deb::CONTENT_TYPE
-                      content[::Katello::Deb::CONTENT_TYPE] << "#{unit['name']}_#{unit['version']}_#{unit['architecture']}"
-                    end
-                  end
-                end
+              new_module_streams.each do |module_stream|
+                content[::Katello::ModuleStream::CONTENT_TYPE] <<
+                  "#{module_stream.name}:#{module_stream.stream}:#{module_stream.version}"
+              end
+              new_rpms.each do |rpm|
+                content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
               end
             end
           end
@@ -274,6 +262,10 @@ module Actions
                 repo.pulp_id)
             end
           end
+
+          if version.latest? && !version.content_view.composite?
+            version.auto_publish_composites!
+          end
         end
 
         # given a composite version, and a list of new components, calculate the list of all components for the new version

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

@@ -2,8 +2,8 @@ module Actions
   module Katello
     module ContentViewVersion
       class ResetContentViewRepositoriesFromMetadata < Actions::Base
-        def plan(content_view:, metadata:)
-          ::Katello::Pulp3::ContentViewVersion::Import.reset_content_view_repositories_from_metadata!(content_view: content_view, metadata: metadata)
+        def plan(import:)
+          import.reset_content_view_repositories!
         end
       end
     end