katello 3.16.0.rc5.1 → 3.16.2

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

@@ -1,7 +1,9 @@
 module Actions
   module Katello
     module ContentViewVersion
+      # rubocop:disable Metrics/ClassLength
       class IncrementalUpdate < Actions::EntryAction
+        include ::Katello::ContentViewHelper
         attr_accessor :new_content_view_version
 
         HUMANIZED_TYPES = {
@@ -30,6 +32,19 @@ 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_master.pulp3_repository_type_support?("yum") && 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)
+              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],
@@ -41,6 +56,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)
 
             repos_to_clone.each do |source_repos|
               plan_action(Repository::CloneToVersion,
@@ -51,18 +67,24 @@ module Actions
             end
 
             concurrence do
-              if SmartProxy.pulp_master.pulp3_support?(repos_to_clone.first.first)
-                extended_repo_mapping = pulp3_repo_mapping(repository_mapping, old_version)
+              if separated_repo_map[:pulp3_yum].keys.flatten.present?
+                extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum], old_version)
                 unit_map = pulp3_content_mapping(content)
 
-                copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
-                                                   dependency_solving: true).output
-              else
+                unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
+                  copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
+                                                     dependency_solving: true).output
+                end
+              end
+
+              if separated_repo_map[:other].keys.flatten.present?
                 repos_to_clone.each do |source_repos|
-                  copy_action_outputs += copy_repos(repository_mapping[source_repos],
-                                                    new_content_view_version,
-                                                    content,
-                                                    dep_solve)
+                  if separated_repo_map[:other].keys.include?(source_repos)
+                    copy_action_outputs += copy_repos(repository_mapping[source_repos],
+                                                      new_content_view_version,
+                                                      content,
+                                                      dep_solve)
+                  end
                 end
               end
 
@@ -98,11 +120,21 @@ module Actions
 
         def pulp3_repo_mapping(repo_mapping, old_version)
           pulp3_repo_mapping = {}
-          repo_mapping.each do |source_repo, dest_repo|
-            source_repo = source_repo.first.library_instance? ? source_repo : [source_repo.first.library_instance]
-            pulp3_repo_mapping[source_repo.first.id] = { dest_repo: dest_repo.id,
-                                                         base_version: pulp3_dest_base_version(
-                                                           ::Katello::ContentViewVersion.find(old_version.id), dest_repo) }
+          repo_mapping.each do |source_repos, dest_repo|
+            old_version_repo = old_version.repositories.archived.find_by(root_id: dest_repo.root_id)
+
+            next if old_version_repo.version_href == old_version_repo.library_instance.version_href
+
+            source_library_repo = source_repos.first.library_instance? ? source_repos.first : source_repos.first.library_instance
+
+            source_repos = [source_library_repo]
+            if old_version_repo.version_href
+              base_version = old_version_repo.version_href.split("/")[-1].to_i
+            else
+              base_version = 0
+            end
+
+            pulp3_repo_mapping[source_repos.map(&:id)] = { dest_repo: dest_repo.id, base_version: base_version }
           end
           pulp3_repo_mapping
         end
@@ -179,42 +211,44 @@ 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].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[: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
 
-              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
+                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
               end
-            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']}"
-                  when ::Katello::PuppetModule::CONTENT_TYPE
-                    content[::Katello::PuppetModule::CONTENT_TYPE] << "#{unit['author']}-#{unit['name']}-#{unit['version']}"
+            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']}"
+                    when ::Katello::PuppetModule::CONTENT_TYPE
+                      content[::Katello::PuppetModule::CONTENT_TYPE] << "#{unit['author']}-#{unit['name']}-#{unit['version']}"
+                    end
                   end
                 end
               end
@@ -232,8 +266,9 @@ module Actions
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
 
-          unless SmartProxy.pulp_master.pulp3_support?(version.repositories.first)
-            version.repositories.each do |repo|
+          cvv_yum_repos = version.repositories.yum_type
+          unless cvv_yum_repos.empty? || SmartProxy.pulp_master.pulp3_support?(cvv_yum_repos.first)
+            cvv_yum_repos.each do |repo|
               SmartProxy.pulp_master.pulp_api.extensions.send(:module_default).
                 copy(repo.library_instance.pulp_id,
                 repo.pulp_id)
@@ -315,10 +350,6 @@ module Actions
           copy_outputs
         end
 
-        def pulp3_dest_base_version(old_cvv, new_repo)
-          old_cvv.repositories.archived.find_by(root_id: new_repo.root_id).version_href.split("/")[-1].to_i
-        end
-
         def copy_yum_content(new_repo, dep_solve, package_ids, errata_ids)
           copy_outputs = []
           if new_repo.content_type == ::Katello::Repository::YUM_TYPE

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

@@ -5,6 +5,8 @@ module Actions
         # rubocop:disable Metrics/MethodLength
         def plan(product, options = {})
           organization_destroy = options.fetch(:organization_destroy, false)
+          skip_environment_update = options.fetch(:skip_environment_update, false) ||
+              options.fetch(:organization_destroy, false)
 
           unless organization_destroy || product.user_deletable?
             if product.redhat?
@@ -24,11 +26,13 @@ module Actions
 
           sequence do
             unless organization_destroy
+              sequence do
+                # ContentDestroy must be called sequentially due to Candlepin's
+                # issues with running multiple remove_content calls at the same time.
+                plan_content_destruction(product, skip_environment_update)
+              end
               concurrence do
-                product.repositories.in_default_view.each do |repo|
-                  repo_options = options.clone
-                  plan_action(Katello::Repository::Destroy, repo, repo_options)
-                end
+                plan_repo_destruction(product, options)
               end
               plan_action(Candlepin::Product::DeletePools,
                             cp_id: product.cp_id, organization_label: product.organization.label)
@@ -65,6 +69,23 @@ module Actions
           product.pool_products.delete_all
         end
 
+        def plan_content_destruction(product, skip_environment_update)
+          product.repositories.in_default_view.each do |repo|
+            if repo.root.repositories.where.not(id: repo.id).empty? &&
+                !repo.redhat? &&
+                !skip_environment_update
+              plan_action(::Actions::Katello::Product::ContentDestroy, repo.root)
+            end
+          end
+        end
+
+        def plan_repo_destruction(product, options)
+          product.repositories.in_default_view.each do |repo|
+            repo_options = options.clone
+            plan_action(Katello::Repository::Destroy, repo, repo_options.merge(destroy_content: false))
+          end
+        end
+
         def view_versions(product)
           cvvs = product.published_content_view_versions.uniq
           views = cvvs.inject({}) do |result, version|

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

@@ -7,9 +7,11 @@ module Actions
 
         # options:
         #   skip_environment_update - defaults to false. skips updating the CP environment
+        #   destroy_content - can be disabled to skip Candlepin remove_content
         def plan(repository, options = {})
           skip_environment_update = options.fetch(:skip_environment_update, false) ||
               options.fetch(:organization_destroy, false)
+          destroy_content = options.fetch(:destroy_content, true)
           action_subject(repository)
 
           unless repository.destroyable?
@@ -29,7 +31,9 @@ module Actions
             if repository.redhat?
               handle_redhat_content(repository) unless skip_environment_update
             else
-              handle_custom_content(repository) unless skip_environment_update
+              if destroy_content && !skip_environment_update
+                handle_custom_content(repository)
+              end
             end
           end
         end

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

@@ -0,0 +1,64 @@
+module Actions
+  module Katello
+    module Repository
+      class MultiCloneContents < Actions::Base
+        include Actions::Katello::PulpSelector
+        def plan(extended_repo_mapping, options)
+          generate_metadata = options.fetch(:generate_metadata, true)
+          copy_contents = options.fetch(:copy_contents, true)
+          solve_dependencies = options.fetch(:solve_dependencies, false)
+
+          sequence do
+            if copy_contents
+              plan_action(Pulp3::Orchestration::Repository::MultiCopyAllUnits,
+                          extended_repo_mapping,
+                          SmartProxy.pulp_master,
+                          solve_dependencies: solve_dependencies)
+            end
+
+            concurrence do
+              extended_repo_mapping.each do |source_repos, dest_repo_map|
+                if generate_metadata
+                  metadata_generate(source_repos, dest_repo_map[:dest_repo], dest_repo_map[:filters])
+                end
+              end
+
+              extended_repo_mapping.values.each do |dest_repo_map|
+                plan_action(Katello::Repository::IndexContent, id: dest_repo_map[:dest_repo].id)
+              end
+            end
+          end
+        end
+
+        def metadata_generate(source_repositories, new_repository, filters)
+          metadata_options = {}
+
+          if source_repositories.count == 1 && filters.empty?
+            metadata_options[:source_repository] = source_repositories.first
+          end
+
+          check_matching_content = ::Katello::RepositoryTypeManager.find(new_repository.content_type).metadata_publish_matching_check
+          if new_repository.environment && source_repositories.count == 1 && check_matching_content
+            match_check_output = plan_action(Katello::Repository::CheckMatchingContent,
+                                :source_repo_id => source_repositories.first.id,
+                                :target_repo_id => new_repository.id).output
+
+            metadata_options[:matching_content] = match_check_output[:matching_content]
+          end
+
+          plan_action(Katello::Repository::MetadataGenerate, new_repository, metadata_options)
+          unless source_repositories.first.saved_checksum_type == new_repository.saved_checksum_type
+            plan_self(:source_checksum_type => source_repositories.first.saved_checksum_type,
+                      :target_repo_id => new_repository.id)
+          end
+        end
+
+        def finalize
+          repository = ::Katello::Repository.find(input[:target_repo_id])
+          source_checksum_type = input[:source_checksum_type]
+          repository.update!(saved_checksum_type: source_checksum_type) if (repository && source_checksum_type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Actions
+  module Katello
+    module Repository
+      class MultiCloneToVersion < Actions::Base
+        def plan(repository_mapping, content_view_version, options = {})
+          incremental = options.fetch(:incremental, false)
+          content_view = content_view_version.content_view
+          extended_repo_map = extended_repo_mapping(repository_mapping, content_view, incremental)
+          sequence do
+            plan_action(::Actions::Katello::Repository::MultiCloneContents, extended_repo_map,
+                        copy_contents: true,
+                        solve_dependencies: content_view.solve_dependencies,
+                        metadata_generate: !incremental)
+          end
+        end
+
+        def extended_repo_mapping(repo_map, content_view, incremental)
+          # Example: {[source_repos] => {dest_repo: dest_repo, filters: filters}}
+          extended_repo_map = {}
+          repo_map.each do |source_repos, dest_repo|
+            filters = incremental ? [] : content_view.filters.applicable(source_repos.first)
+            extended_repo_map[source_repos] = { :dest_repo => dest_repo,
+                                                :filters => filters }
+          end
+          extended_repo_map
+        end
+      end
+    end
+  end
+end

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

@@ -34,38 +34,47 @@ module Actions
 
           pulp_sync_options = {}
           pulp_sync_options[:download_policy] = ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND if validate_contents && repo.yum?
+
+          #pulp2 options
           pulp_sync_options[:force_full] = true if skip_metadata_check && repo.yum?
           pulp_sync_options[:repair_sync] = true if validate_contents && repo.deb?
           pulp_sync_options[:remove_missing] = false if incremental
+          pulp_sync_options[:source_url] = source_url
+
+          #pulp3 options
+          pulp_sync_options[:optimize] = false if skip_metadata_check && repo.yum?
 
           sequence do
-            plan_action(Pulp::Repository::RemoveUnits, :repo_id => repo.id, :content_unit_type => ::Katello::YumMetadataFile::CONTENT_TYPE) if validate_contents && repo.yum?
-            sync_args = {:smart_proxy_id => SmartProxy.pulp_master.id, :repo_id => repo.id, :source_url => source_url, :options => pulp_sync_options}
-            sync_action = plan_pulp_action([Actions::Pulp::Orchestration::Repository::Sync,
-                                            Actions::Pulp3::Orchestration::Repository::Sync],
-                                           repo,
-                                           SmartProxy.pulp_master,
-                                           sync_args)
-            output = sync_action.output
-
-            contents_changed = skip_metadata_check || output[:contents_changed]
-
-            plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
-            plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
-            plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
-            plan_action(Katello::Repository::CorrectChecksum, repo)
-            concurrence do
-              plan_action(Pulp::Repository::Download, :pulp_id => repo.pulp_id, :options => {:verify_all_units => true}) if validate_contents && repo.yum?
-              plan_action(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check && repo.yum?
-              plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
-              if generate_applicability
-                regenerate_applicability(repo, contents_changed)
+            if SmartProxy.pulp_master.pulp3_support?(repo) && validate_contents
+              plan_action(Katello::Repository::VerifyChecksum, repo)
+            else
+              plan_action(Pulp::Repository::RemoveUnits, :repo_id => repo.id, :content_unit_type => ::Katello::YumMetadataFile::CONTENT_TYPE) if validate_contents && repo.yum?
+              sync_action = plan_pulp_action([Actions::Pulp::Orchestration::Repository::Sync,
+                                              Actions::Pulp3::Orchestration::Repository::Sync],
+                                             repo,
+                                             SmartProxy.pulp_master,
+                                             pulp_sync_options)
+              output = sync_action.output
+
+              contents_changed = skip_metadata_check || output[:contents_changed]
+
+              plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
+              plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
+              plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
+              plan_action(Katello::Repository::CorrectChecksum, repo)
+              concurrence do
+                plan_action(Pulp::Repository::Download, :pulp_id => repo.pulp_id, :options => {:verify_all_units => true}) if validate_contents && repo.yum?
+                plan_action(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check && repo.yum?
+                plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
+                if generate_applicability
+                  regenerate_applicability(repo, contents_changed)
+                end
               end
+              plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
+                        :contents_changed => contents_changed)
+              plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed) if generate_applicability
+              plan_action(Katello::Repository::SyncHook, :id => repo.id)
             end
-            plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
-                      :contents_changed => contents_changed)
-            plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed) if generate_applicability
-            plan_action(Katello::Repository::SyncHook, :id => repo.id)
           end
         end
 
@@ -91,6 +100,7 @@ module Actions
         def presenter
           found = all_planned_actions(Pulp::Repository::Sync)
           found = all_planned_actions(Pulp3::Repository::Sync) if found.empty?
+          found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?
           Helpers::Presenter::Delegated.new(self, found)
         end
 

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

@@ -10,8 +10,7 @@ module Actions
           action_subject root.library_instance
 
           repo_params[:url] = nil if repo_params[:url] == ''
-          update_cv_cert_protected = (repo_params[:unprotected] != repository.unprotected)
-
+          update_cv_cert_protected = repo_params.key?(:unprotected) && (repo_params[:unprotected] != repository.unprotected)
           root.update!(repo_params)
 
           if root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
@@ -42,28 +41,24 @@ module Actions
                                        gpg_url: repository.yum_gpg_key_url)
           end
           if root.pulp_update_needed?
-            plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
-                              ::Actions::Pulp3::Orchestration::Repository::Update],
-                             repository,
-                             SmartProxy.pulp_master)
-            plan_self(:repository_id => root.library_instance.id, :update_cv_cert_protected => update_cv_cert_protected)
+            sequence do
+              plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
+                                ::Actions::Pulp3::Orchestration::Repository::Update],
+                               repository,
+                               SmartProxy.pulp_master)
+              plan_self(:repository_id => root.library_instance.id)
+              if update_cv_cert_protected
+                plan_optional_pulp_action([::Actions::Pulp3::Orchestration::Repository::TriggerUpdateRepoCertGuard], repository, ::SmartProxy.pulp_master)
+              end
+            end
           end
         end
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
-          output[:repository_id] = input[:repository_id]
-          output[:update_cv_cert_protected] = input[:update_cv_cert_protected]
           ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
         end
 
-        def finalize
-          repository = ::Katello::Repository.find(output[:repository_id])
-          if output[:update_cv_cert_protected]
-            ForemanTasks.async_task(::Actions::Katello::Repository::UpdateCVRepoCertGuard, repository, SmartProxy.pulp_master)
-          end
-        end
-
         private
 
         def update_content?(repository)