katello 3.16.0 → 3.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c1b5ae508e6d13abb97dd4fa5dcb3a869b5a8ee2f6a2a2e574bcde16faa1c41
-  data.tar.gz: e5dc1c88a336020bf333e9f781eac5790b588139bd8d813433bea739ee7077ca
+  metadata.gz: 961e7dd9a56b1752c55e19c1f29dc6b4e55366db3e87ab59610d7b89e8dea975
+  data.tar.gz: aa5c95aec6191209c2bc76988bc81b18984167176bf71eaa4186f517a06028f6
 SHA512:
-  metadata.gz: c6e0279e68e389701bcf84815bd401fe64375259da0ff533e4ae53fbf51f99b93837be754c0fb8d2d0457e6a8d299e4527c26d5c51fb4e81870f78592bbd46bf
-  data.tar.gz: 2296caf477bbb72d78f187e53a493b9e4c8657119424939063a8a6c6c40435d5e9bda70490351101207694cf9511a59de939397c53c623f11a2f30eba564ff91
+  metadata.gz: a60d61a7d375ff622d7d4db78fd7c5da3d78f8421d45cb5204ce7b690b031515412e727e03c906d96fb3ba538c585819350c2671d103e6415ea51987481df037
+  data.tar.gz: b62c7366deacc4d5875488bff0913e11fa61cf0a4e7077391a459a78587d598b032ce815b45ade45d0e6e3e870e09e87ebef0ba60034d5166aa83cf8520f501e

data/app/controllers/katello/api/rhsm/candlepin_proxies_controller.rb

@@ -480,7 +480,7 @@ module Katello
         else
           User.consumer? || ::User.current.can?(:view_organizations, self)
         end
-      when "rhsm_proxy_owner_servicelevels_path"
+      when "rhsm_proxy_owner_servicelevels_path", "rhsm_proxy_owner_system_purpose_path"
         (User.consumer? || ::User.current.can?(:view_organizations, self))
       when "rhsm_proxy_consumer_accessible_content_path", "rhsm_proxy_consumer_certificates_path",
            "rhsm_proxy_consumer_releases_path", "rhsm_proxy_certificate_serials_path",

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

@@ -2,11 +2,6 @@ module Katello
   class Api::V2::HostTracerController < Api::V2::ApiController
     before_action :find_host, :only => :index
 
-    resource_description do
-      api_version 'v2'
-      api_base_url "/api"
-    end
-
     api :GET, "/hosts/:host_id/traces", N_("List services that need restarting on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     def index

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

@@ -50,6 +50,21 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :PUT, "/products/bulk/verify_checksum", N_("Verify checksum for one or more products")
+    param :ids, Array, :desc => N_("List of product ids"), :required => true
+    def verify_checksum_products
+      repairable_products = @products.syncable
+      repairable_roots = RootRepository.where(:product_id => repairable_products).
+        where(:content_type => ::Katello::Repository::YUM_TYPE).has_url.select { |r| r.library_instance }.uniq
+
+      repairable_repositories = Katello::Repository.where(:root_id => repairable_roots)
+      task = async_task(::Actions::BulkAction,
+                        ::Actions::Katello::Repository::VerifyChecksum,
+                        repairable_repositories)
+
+      respond_for_async :resource => task
+    end
+
     api :PUT, "/products/bulk/http_proxy", N_("Update the HTTP proxy configuration on the repositories of one or more products.")
     param :ids, Array, :desc => N_("List of product ids"), :required => true
     param :http_proxy_policy, ::Katello::RootRepository::HTTP_PROXY_POLICIES, :desc => N_("policy for HTTP proxy for content sync")

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

@@ -15,7 +15,7 @@ module Katello
     before_action :find_organization_from_product, :only => [:create]
     before_action :find_repository, :only => [:show, :update, :destroy, :sync, :export,
                                               :remove_content, :upload_content, :republish,
-                                              :import_uploads, :gpg_key_content]
+                                              :import_uploads, :gpg_key_content, :verify_checksum]
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
     before_action :error_on_rh_product, :only => [:create]
@@ -294,6 +294,15 @@ module Katello
       raise HttpErrors::BadRequest, e.message
     end
 
+    api :POST, "/repositories/:id/verify_checksum", N_("Verify checksum of repository contents")
+    param :id, :number, :required => true, :desc => N_("repository ID")
+    def verify_checksum
+      task = async_task(::Actions::Katello::Repository::VerifyChecksum, @repository)
+      respond_for_async :resource => task
+    rescue Errors::InvalidActionOptionError => e
+      raise HttpErrors::BadRequest, e.message
+    end
+
     api :POST, "/repositories/:id/export", N_("Export a repository")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
     param :export_to_iso, :bool, :desc => N_("Export to ISO format"), :required => false

data/app/controllers/katello/concerns/hosts_controller_extensions.rb

@@ -19,11 +19,17 @@ module Katello
         prepend Overrides
 
         def update_multiple_taxonomies(type)
-          registered_host = @hosts.detect { |host| host.subscription_facet }
-          unless registered_host.nil?
-            error _("Unregister host %s before assigning an organization") % registered_host.name
-            redirect_back_or_to hosts_path
-            return
+          if type == :organization
+            new_org_id = params.dig(type, 'id')
+
+            if new_org_id
+              registered_host = @hosts.where.not(organization_id: new_org_id).joins(:subscription_facet).first
+              if registered_host
+                error _("Unregister host %s before assigning an organization") % registered_host.name
+                redirect_back_or_to hosts_path
+                return
+              end
+            end
           end
 
           super

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

@@ -31,8 +31,8 @@ module Actions
           fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_master?
 
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
-          repositories = smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository)
-          smart_proxy.ping_pulp3 if repositories.any? { |repo| smart_proxy.pulp3_support?(repo) }
+          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) }
 
           refresh_options = options.merge(content_view: content_view,
@@ -40,6 +40,7 @@ module Actions
                                              repository: repository)
           sequence do
             plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy) if repositories.any? { |repo| smart_proxy.pulp3_support?(repo) }
             plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.pulp3_enabled?
             plan_action(SyncCapsule, smart_proxy, refresh_options)
           end

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/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

@@ -46,19 +46,15 @@ module Actions
 
           plan_action(Katello::Repository::MetadataGenerate, new_repository, metadata_options)
           unless source_repositories.first.saved_checksum_type == new_repository.saved_checksum_type
-            checksum_mapping = {}
-            repository_mapping.each do |source_repos, dest_repo|
-              checksum_mapping[dest_repo.id] = source_repos.first.saved_checksum_type
-            end
-            plan_self(:checksum_mapping => checksum_mapping)
+            plan_self(:source_checksum_type => source_repositories.first.saved_checksum_type,
+                      :target_repo_id => new_repository.id)
           end
         end
 
         def finalize
-          input[:checksum_mapping].each do |repo_id, checksum_type|
-            repository = ::Katello::Repository.find(repo_id)
-            repository.update!(saved_checksum_type: checksum_type) if (repository && checksum_type)
-          end
+          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

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)

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

@@ -0,0 +1,28 @@
+module Actions
+  module Katello
+    module Repository
+      class VerifyChecksum < Actions::EntryAction
+        include Helpers::Presenter
+        include Actions::Katello::PulpSelector
+
+        def plan(repo)
+          action_subject(repo)
+
+          if SmartProxy.pulp_master.pulp3_support?(repo)
+            plan_action(Actions::Pulp3::Repository::Repair, repo.id, SmartProxy.pulp_master)
+          else
+            options = {}
+            options[:validate_contents] = true
+            plan_action(Actions::Katello::Repository::Sync, repo, nil, options)
+          end
+        end
+
+        def presenter
+          found = all_planned_actions(Katello::Repository::Sync)
+          found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?
+          Helpers::Presenter::Delegated.new(self, found)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp/orchestration/repository/sync.rb

@@ -4,8 +4,9 @@ module Actions
       module Repository
         class Sync < Pulp::Abstract
           include Actions::Helpers::OutputPropagator
-          def plan(_repository, _smart_proxy, options)
+          def plan(repository, smart_proxy, options)
             sequence do
+              options.merge!(:repo_id => repository.id, :smart_proxy_id => smart_proxy.id)
               action_output = plan_action(Actions::Pulp::Repository::Sync, options).output
               plan_self(:subaction_output => action_output)
             end

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

@@ -14,8 +14,9 @@ module Actions
           overrides = {}
           overrides[:feed] = input[:source_url] if input[:source_url]
           overrides[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
-          overrides[:options] = input[:options] if input[:options]
+          overrides.merge(input[:options]) if input[:options]
           repo = ::Katello::Repository.find(input[:repo_id])
+
           output[:pulp_tasks] = repo.backend_service(::SmartProxy.pulp_master).sync(overrides)
         end