katello 3.17.0.rc1 → 3.17.0.rc2

data/app/helpers/katello/content_view_helper.rb

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

data/app/lib/actions/candlepin/product/content_add.rb

@@ -6,12 +6,11 @@ module Actions
           param :product_id
           param :content_id
           param :owner
-          param :enabled
         end
 
         def run
           output[:response] = ::Katello::Resources::Candlepin::Product.
-              add_content(input[:owner], input[:product_id], input[:content_id], input[:enabled])
+              add_content(input[:owner], input[:product_id], input[:content_id], true)
         end
       end
     end

data/app/lib/actions/katello/capsule_content/refresh_repos.rb

@@ -37,7 +37,7 @@ module Actions
           current_repos_on_capsule = smart_proxy_service.current_repositories(environment, content_view)
           current_repos_on_capsule_ids = current_repos_on_capsule.pluck(:id)
 
-          list_of_repos_to_sync = smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository)
+          list_of_repos_to_sync = smart_proxy_helper.combined_repos_available_to_capsule(environment, content_view, repository)
           list_of_repos_to_sync.each do |repo|
             if repo.is_a?(Katello::ContentViewPuppetEnvironment)
               repo = repo.nonpersisted_repository

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

@@ -28,10 +28,10 @@ module Actions
           content_view_id = options.fetch(:content_view_id, nil)
           content_view = ::Katello::ContentView.find(content_view_id) if content_view_id
 
-          fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_master?
+          fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_primary?
 
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
-          repositories = smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository)
+          repositories = smart_proxy_helper.combined_repos_available_to_capsule(environment, content_view, repository)
 
           smart_proxy.ping_pulp if repositories.any? { |repo| !smart_proxy.pulp3_support?(repo) }
 

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -10,11 +10,12 @@ module Actions
           repository = options[:repository]
           skip_metadata_check = options.fetch(:skip_metadata_check, false)
 
-          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
           sequence do
-            smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository).in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repos|
+            repos = repos_to_sync(smart_proxy, environment, content_view, repository)
+
+            repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
-                repos.each do |repo|
+                repo_batch.each do |repo|
                   plan_pulp_action([Actions::Pulp::Orchestration::Repository::SmartProxySync,
                                     Actions::Pulp3::CapsuleContent::Sync],
                                      repo, smart_proxy,
@@ -33,6 +34,19 @@ module Actions
           end
         end
 
+        def repos_to_sync(smart_proxy, environment, content_view, repository)
+          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+          smart_proxy_helper.lifecycle_environment_check(environment, repository)
+
+          if repository
+            [repository]
+          else
+            repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
+            puppet_envs = smart_proxy_helper.puppet_environments_available_to_capsule(environment, content_view)
+            repositories + puppet_envs
+          end
+        end
+
         def resource_locks
           :link
         end

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

@@ -11,7 +11,7 @@ module Actions
             concurrence do
               smart_proxies = SmartProxy.with_environment(environment)
               unless smart_proxies.blank?
-                plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies,
+                plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies.sort,
                             :content_view_id => content_view.id, :environment_id => environment.id)
               end
             end

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

@@ -17,8 +17,8 @@ module Actions
               end
             end
 
-            if SmartProxy.pulp_master&.pulp3_enabled?
-              plan_action(Actions::Pulp3::ContentView::DeleteRepositoryReferences, content_view, SmartProxy.pulp_master)
+            if SmartProxy.pulp_primary&.pulp3_enabled?
+              plan_action(Actions::Pulp3::ContentView::DeleteRepositoryReferences, content_view, SmartProxy.pulp_primary)
             end
             plan_self
           end

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

@@ -52,7 +52,7 @@ module Actions
               action = plan_action(ContentViewVersion::IncrementalUpdate, composite_version, environments,
                                    :new_components => new_components, :description => description,
                                                            :content => {:puppet_module_ids => puppet_module_ids})
-              unless SmartProxy.pulp_master.pulp3_repository_type_support?("yum")
+              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
             end

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

@@ -47,6 +47,7 @@ module Actions
           ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
                                               :lifecycle_environment_id => input[:environment_id]).each do |facet|
             facet.update_applicability_counts
+            facet.update_errata_status
           end
 
           history = ::Katello::ContentViewHistory.find(input[:history_id])

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

@@ -5,7 +5,7 @@ module Actions
       class Publish < Actions::EntryAction
         include ::Katello::ContentViewHelper
         attr_accessor :version
-        # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
         def plan(content_view, description = "", options = {})
           action_subject(content_view)
           content_view.check_ready_to_publish!
@@ -50,7 +50,7 @@ module Actions
             separated_repo_map = separated_repo_mapping(repository_mapping)
 
             if separated_repo_map[:pulp3_yum].keys.flatten.present? &&
-                SmartProxy.pulp_master.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
+                SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
               plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
             end
 
@@ -69,15 +69,19 @@ module Actions
                 plan_action(Repository::Destroy, repo, :skip_environment_update => true)
               end
             end
-            has_modules = content_view.publish_puppet_environment?
-            plan_action(ContentViewPuppetEnvironment::CreateForVersion, version)
-            unless options[:skip_promotion]
-              plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
-                  :puppet_modules_present => has_modules)
+
+            if SmartProxy.pulp_primary.has_feature?(SmartProxy::PULP_FEATURE)
+              has_modules = content_view.publish_puppet_environment?
+              plan_action(ContentViewPuppetEnvironment::CreateForVersion, version)
+              unless options[:skip_promotion]
+                plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
+                    :puppet_modules_present => has_modules)
+              end
             end
             plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library)) unless options[:skip_promotion]
             plan_action(Katello::Foreman::ContentUpdate, library, content_view) unless options[:skip_promotion]
             plan_action(ContentView::ErrataMail, content_view, library) unless options[:skip_promotion]
+
             plan_self(history_id: history.id, content_view_id: content_view.id,
                       auto_publish_composite_ids: auto_publish_composite_ids(content_view),
                       content_view_version_name: version.name,
@@ -118,6 +122,7 @@ module Actions
             ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
                                                 :lifecycle_environment_id => input[:environment_id]).each do |facet|
               facet.update_applicability_counts
+              facet.update_errata_status
             end
           end
 

data/app/lib/actions/katello/content_view_puppet_environment/clone.rb

@@ -46,7 +46,7 @@ module Actions
             clone.save!
             plan_action(ContentViewPuppetEnvironment::Clear, clone)
 
-            unless ::Katello::Repository.needs_distributor_updates([clone], SmartProxy.pulp_master).empty?
+            unless ::Katello::Repository.needs_distributor_updates([clone], SmartProxy.pulp_primary).empty?
               plan_action(Pulp::Repository::Refresh, clone)
             end
           end

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

@@ -3,7 +3,7 @@ module Actions
     module ContentViewPuppetEnvironment
       class Create < Actions::EntryAction
         def plan(puppet_environment, clone = false)
-          internal_capsule = SmartProxy.pulp_master
+          internal_capsule = SmartProxy.pulp_primary
           fail _("Content View %s  cannot be published without an internal capsule." % puppet_environment.name) unless internal_capsule
 
           User.as_anonymous_admin { puppet_environment.save! }
@@ -22,7 +22,7 @@ module Actions
 
         def run
           puppet_environment = ::Katello::ContentViewPuppetEnvironment.find(input[:content_view_puppet_environment_id])
-          output[:response] = ::Katello::Pulp::Repository::Puppet.new(puppet_environment.nonpersisted_repository, SmartProxy.pulp_master).create
+          output[:response] = ::Katello::Pulp::Repository::Puppet.new(puppet_environment.nonpersisted_repository, SmartProxy.pulp_primary).create
         end
 
         def humanized_name

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

@@ -32,7 +32,7 @@ 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
+          if SmartProxy.pulp_primary.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,
@@ -73,7 +73,7 @@ module Actions
 
                 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
+                                                     dependency_solving: dep_solve).output
                 end
               end
 
@@ -266,9 +266,9 @@ module Actions
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
 
-          unless SmartProxy.pulp_master.pulp3_support?(version.repositories.first)
+          unless SmartProxy.pulp_primary.pulp3_support?(version.repositories.first)
             version.repositories.each do |repo|
-              SmartProxy.pulp_master.pulp_api.extensions.send(:module_default).
+              SmartProxy.pulp_primary.pulp_api.extensions.send(:module_default).
                 copy(repo.library_instance.pulp_id,
                 repo.pulp_id)
             end

data/app/lib/actions/katello/organization/manifest_delete.rb

@@ -40,6 +40,7 @@ module Actions
         end
 
         def finalize
+          subject_organization.clear_syspurpose_status if subject_organization.simple_content_access?(cached: false)
           subject_organization.audit_manifest_action(_('Manifest deleted'))
         end
       end

data/app/lib/actions/katello/organization/manifest_import.rb

@@ -45,6 +45,7 @@ module Actions
         end
 
         def finalize
+          subject_organization.clear_syspurpose_status if subject_organization.simple_content_access?(cached: false)
           subject_organization.clear_manifest_expired_notifications
           subject_organization.audit_manifest_action(_('Manifest imported'))
         end

data/app/lib/actions/katello/organization/manifest_refresh.rb

@@ -61,6 +61,7 @@ module Actions
 
         def finalize
           org = ::Organization.find(input[:organization_id])
+          subject_organization.clear_syspurpose_status if subject_organization.simple_content_access?(cached: false)
           org.clear_manifest_expired_notifications
           subject_organization.audit_manifest_action(_('Manifest refreshed'))
         end

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

@@ -17,8 +17,7 @@ module Actions
               content_id = content_create.output[:response][:id]
               plan_action(Candlepin::Product::ContentAdd, owner: root.product.organization.label,
                                     product_id: root.product.cp_id,
-                                    content_id: content_id,
-                                    enabled: root.auto_enabled?)
+                                    content_id: content_id)
 
             else
               content_id = root.content_id
@@ -52,7 +51,8 @@ module Actions
                                                content_url: root.custom_content_path,
                                                vendor: ::Katello::Provider::CUSTOM)
 
-          ::Katello::ProductContent.create!(product: root.product, content: content, enabled: root.auto_enabled?)
+          #custom product content is always enabled by default
+          ::Katello::ProductContent.create!(product: root.product, content: content, enabled: true)
         end
       end
     end

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/clone_contents.rb

@@ -15,7 +15,7 @@ module Actions
             if copy_contents
               plan_pulp_action([Pulp3::Orchestration::Repository::CopyAllUnits, Pulp::Orchestration::Repository::CopyAllUnits],
                           new_repository,
-                          SmartProxy.pulp_master,
+                          SmartProxy.pulp_primary,
                           source_repositories,
                           filters: filters, rpm_filenames: rpm_filenames, solve_dependencies: solve_dependencies)
             end
@@ -26,7 +26,7 @@ module Actions
             index_options[:source_repository_id] = source_repositories.first.id if source_repositories.count == 1 && filters.empty? && rpm_filenames.nil?
             plan_action(Katello::Repository::IndexContent, index_options)
 
-            if purge_empty_contents && new_repository.backend_service(SmartProxy.pulp_master).should_purge_empty_contents?
+            if purge_empty_contents && new_repository.backend_service(SmartProxy.pulp_primary).should_purge_empty_contents?
               plan_action(Katello::Repository::PurgeEmptyContent, id: new_repository.id)
             end
           end
@@ -40,7 +40,7 @@ module Actions
           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 && !SmartProxy.pulp_master.pulp3_support?(new_repository)
+          if new_repository.environment && source_repositories.count == 1 && check_matching_content && !SmartProxy.pulp_primary.pulp3_support?(new_repository)
             match_check_output = plan_action(Katello::Repository::CheckMatchingContent,
                                 :source_repo_id => source_repositories.first.id,
                                 :target_repo_id => new_repository.id).output

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

@@ -13,9 +13,9 @@ module Actions
               plan_action(Repository::Create, clone, true, false)
             else
               #only clear if it should be empty, but its not
-              plan_optional_pulp_action([Actions::Pulp::Repository::Clear], clone, SmartProxy.pulp_master)
+              plan_optional_pulp_action([Actions::Pulp::Repository::Clear], clone, SmartProxy.pulp_primary)
               # Do we need to refresh distributors here?
-              plan_optional_pulp_action([Actions::Pulp::Orchestration::Repository::RefreshIfNeeded], clone, SmartProxy.pulp_master)
+              plan_optional_pulp_action([Actions::Pulp::Orchestration::Repository::RefreshIfNeeded], clone, SmartProxy.pulp_primary)
             end
 
             plan_action(::Actions::Katello::Repository::CloneContents, [repository], clone, :copy_contents => !clone.yum?)

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

@@ -13,7 +13,7 @@ module Actions
             Rails.logger.warn("Filters on content view have been overridden by passed-in filename list during publish") if filters.any?
           end
 
-          copy_contents = destination_repository.master?
+          copy_contents = destination_repository.primary?
           fail _('Cannot publish a link repository if multiple component clones are specified') if !copy_contents && repositories.count > 1
 
           sequence do

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

@@ -22,7 +22,7 @@ module Actions
           pulp2_create_action = plan_create ? Actions::Pulp::Repository::CreateInPlan : Actions::Pulp::Repository::Create
           sequence do
             create_action = plan_pulp_action([pulp2_create_action, Pulp3::Orchestration::Repository::Create],
-                                        repository, SmartProxy.pulp_master)
+                                        repository, SmartProxy.pulp_primary)
 
             return if create_action.error
 

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?
@@ -22,21 +24,24 @@ module Actions
           plan_pulp_action([Actions::Pulp::Orchestration::Repository::Delete,
                             Actions::Pulp3::Orchestration::Repository::Delete],
                            repository,
-                           SmartProxy.pulp_master)
+                           SmartProxy.pulp_primary)
 
           plan_self(:user_id => ::User.current.id)
           sequence do
             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
 
         def finalize
           repository = ::Katello::Repository.find(input[:repository][:id])
-          delete_record(repository)
+          docker_cleanup = repository.content_type == ::Katello::Repository::DOCKER_TYPE
+          delete_record(repository, {docker_cleanup: docker_cleanup})
         end
 
         def handle_custom_content(repository)
@@ -52,9 +57,10 @@ module Actions
           end
         end
 
-        def delete_record(repository)
+        def delete_record(repository, options = {})
           repository.destroy!
           repository.root.destroy! if repository.root.repositories.empty?
+          ::Katello::DockerMetaTag.cleanup_tags if options[:docker_cleanup]
         end
 
         def humanized_name

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

@@ -15,7 +15,7 @@ module Actions
           end
 
           unless File.writable?(Setting['pulp_export_destination'])
-            fail ::Foreman::Exception, N_("Unable to export, 'pulp_export_destination' setting is not a writable directory.")
+            fail ::Foreman::Exception, N_("Unable to export. 'pulp_export_destination' setting is not a writable directory.")
           end
 
           repo_pulp_ids = repos.collect do |repo|
@@ -68,8 +68,8 @@ module Actions
             repos.each do |repo|
               sequence do
                 if repo.link?
-                  plan_action(Pulp::Repository::Clear, repo, SmartProxy.pulp_master!)
-                  plan_action(Pulp::Repository::CopyAllUnits, repo, ::SmartProxy.pulp_master, repo.target_repository)
+                  plan_action(Pulp::Repository::Clear, repo, SmartProxy.pulp_primary!)
+                  plan_action(Pulp::Repository::CopyAllUnits, repo, ::SmartProxy.pulp_primary, repo.target_repository)
                 end
               end
             end