katello 4.12.1 → 4.13.0

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

@@ -112,6 +112,30 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :POST, '/capsules/:id/content/verify_checksum', N_('Check for missing or corrupted artifacts, and attempt to redownload them.')
+    param :id, :number, :required => true, :desc => N_('Id of the smart proxy')
+    param :environment_id, Integer, :desc => N_('Id of the environment to limit verifying checksum on')
+    param :content_view_id, Integer, :desc => N_('Id of the content view to limit verifying checksum on')
+    param :repository_id, Integer, :desc => N_('Id of the repository to limit verifying checksum on')
+    def verify_checksum
+      find_capsule(false)
+      find_environment if params[:environment_id]
+      find_content_view if params[:content_view_id]
+      find_repository if params[:repository_id]
+
+      repair_options = {
+        :environment_id => @environment.try(:id),
+        :content_view_id => @content_view.try(:id),
+        :repository_id => @repository.try(:id)
+      }
+      repair_options[:environment_ids] = @capsule.lifecycle_environments&.pluck(:id) unless (@environment || @content_view || @repository)
+
+      task = async_task(::Actions::Katello::CapsuleContent::VerifyChecksum,
+                        @capsule,
+                        repair_options)
+      respond_for_async :resource => task
+    end
+
     protected
 
     def respond_for_lifecycle_environments_index(environments)

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

@@ -3,8 +3,8 @@ module Katello
     include ::Api::V2::BulkHostsExtension
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_action :find_authorized_katello_resource, :only => [:show, :update, :promote, :destroy, :republish_repositories]
-    before_action :find_content_view_from_version, :only => [:show, :update, :promote, :destroy, :republish_repositories]
+    before_action :find_authorized_katello_resource, :only => [:show, :update, :promote, :destroy, :republish_repositories, :verify_checksum]
+    before_action :find_content_view_from_version, :only => [:show, :update, :promote, :destroy, :republish_repositories, :verify_checksum]
     before_action :find_optional_readable_content_view, :only => [:index]
 
     before_action :find_environment, :only => [:index]
@@ -141,6 +141,13 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. New ver
       respond_for_async :resource => task
     end
 
+    api :POST, "/content_view_versions/:id/verify_checksum", N_("Verify checksum of repository contents in the content view version")
+    param :id, :number, :required => true, :desc => N_("Content view version identifier")
+    def verify_checksum
+      task = async_task(::Actions::Katello::ContentViewVersion::VerifyChecksum, @content_view_version)
+      respond_for_async :resource => task
+    end
+
     private
 
     def calculate_hosts_for_incremental(bulk_params, use_composites)

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

@@ -37,7 +37,7 @@ module Katello
     api :GET, "/repositories/:repository_id/debs", N_("List deb packages")
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
-    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier. Use to filter by ID")
     param :repository_id, :number, :desc => N_("Repository identifier")
     param :environment_id, :number, :desc => N_("Environment identifier")
     param :ids, Array, :desc => N_("Deb package identifiers to filter content by")

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

@@ -9,7 +9,7 @@ module Katello
     api :GET, "/errata", N_("List errata")
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
-    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier. Use to filter by ID")
     param :repository_id, :number, :desc => N_("Repository identifier")
     param :environment_id, :number, :desc => N_("Environment identifier")
     param :cve, String, :desc => N_("CVE identifier")

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

@@ -33,9 +33,14 @@ module Katello
       api_base_url "/api"
     end
 
-    api :GET, "/hosts/:host_id/subscriptions", N_("List a host's subscriptions")
+    def deprecate_entitlement_mode_endpoint
+      ::Foreman::Deprecation.api_deprecation_warning(N_("This endpoint is deprecated and will be removed in an upcoming release. Simple Content Access is the only supported content access mode."))
+    end
+
+    api :GET, "/hosts/:host_id/subscriptions", N_("List a host's subscriptions"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     def index
+      deprecate_entitlement_mode_endpoint
       @collection = index_response
       respond_for_index :collection => @collection
     end
@@ -47,9 +52,10 @@ module Katello
       full_result_response(presenter.subscriptions)
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions")
+    api :PUT, "/hosts/:host_id/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     def auto_attach
+      deprecate_entitlement_mode_endpoint
       if @host.organization.simple_content_access?
         fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Auto-attach is disabled")
       end
@@ -111,13 +117,14 @@ module Katello
       rhsm_params
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/remove_subscriptions"
+    api :PUT, "/hosts/:host_id/subscriptions/remove_subscriptions", N_("Remove subscriptions from a host"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
       param :quantity, Integer, :desc => N_("If specified, remove the first instance of a subscription with matching id and quantity"), :required => false
     end
     def remove_subscriptions
+      deprecate_entitlement_mode_endpoint
       #combine the quantities for duplicate pools into PoolWithQuantities objects
       pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
         new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.with_identifier(subscription['id']))
@@ -129,13 +136,14 @@ module Katello
       respond_for_index(:collection => index_response(reload_host: true), :template => "index")
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host")
+    api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
       param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
     end
     def add_subscriptions
+      deprecate_entitlement_mode_endpoint
       if @host.organization.simple_content_access?
         fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Attaching subscriptions is disabled.")
       end

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

@@ -106,7 +106,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts")
+    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts"), deprecated: true
     param_group :bulk_params
     param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
@@ -123,7 +123,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts")
+    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts"), deprecated: true
     param_group :bulk_params
     param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
@@ -142,7 +142,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts")
+    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts"), deprecated: true
     param_group :bulk_params
     def auto_attach
       task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AutoAttachSubscriptions, @hosts)

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

@@ -56,22 +56,11 @@ module Katello
     api :PUT, '/organizations/:id', N_('Update organization')
     param :id, :number, :desc => N_("organization ID"), :required => true
     param :redhat_repository_url, String, :desc => N_("Red Hat CDN URL"), deprecated: true
-    param :simple_content_access, :bool, :desc => N_('Whether Simple Content Access should be enabled for the organization.'), :required => false, :default => true, deprecated: true
     param_group :resource
     def update
       if params[:redhat_repository_url]
         sync_task(::Actions::Katello::CdnConfiguration::Update, @organization.cdn_configuration, url: params[:redhat_repository_url])
       end
-      unless params[:simple_content_access].nil?
-        sca_param = ::Foreman::Cast.to_bool(params[:simple_content_access])
-        if sca_param && !@taxonomy.simple_content_access?(cached: false)
-          # user has requested SCA enable
-          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
-        elsif !sca_param && @taxonomy.simple_content_access?(cached: false)
-          # user has requested SCA disable
-          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
-        end
-      end
       super
     end
 

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

@@ -32,7 +32,7 @@ module Katello
     api :GET, "/repositories/:repository_id/:resource_id", N_("List :resource_id")
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
-    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier. Use to filter by ID")
     param :repository_id, :number, :desc => N_("Repository identifier")
     param :environment_id, :number, :desc => N_("Environment identifier")
     param :ids, Array, :desc => N_("Package identifiers to filter content by")

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

@@ -48,7 +48,7 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
       param :ssl_client_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Cert"), :allow_nil => true
       param :ssl_client_key_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Key"), :allow_nil => true
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
-      param :checksum_type, String, :desc => N_("Checksum of the repository, currently 'sha1' & 'sha256' are supported")
+      param :checksum_type, String, :desc => N_("Checksum used for published repository contents. Supported types: %s") % Katello::RootRepository::CHECKSUM_TYPES.join(', ')
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
       param :include_tags, Array, :desc => N_("Comma-separated list of tags to sync for a container image repository")
       param :exclude_tags, Array, :desc => N_("Comma-separated list of tags to exclude when syncing a container image repository. Default: any tag ending in \"-source\"")
@@ -58,7 +58,7 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
       param :upstream_username, String, :desc => N_("Username of the upstream repository user used for authentication")
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
-      param :upstream_authentication_token, String, :desc => N_("Password of the upstream authentication token.")
+      param :upstream_authentication_token, String, :desc => N_("Upstream authentication token string for yum repositories.")
       param :deb_releases, String, :desc => N_("whitespace-separated list of releases to be synced from deb-archive")
       param :deb_components, String, :desc => N_("whitespace-separated list of repo components to be synced from deb-archive")
       param :deb_architectures, String, :desc => N_("whitespace-separated list of architectures to be synced from deb-archive")
@@ -576,13 +576,15 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
     end
 
     # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def repository_params
       keys = [:download_policy, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
-              :upstream_username, :download_concurrency, :upstream_authentication_token, :metadata_expire,
+              :upstream_username, :download_concurrency, :metadata_expire,
               {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
               :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
              ]
       keys += [{:include_tags => []}, {:exclude_tags => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
+      keys += [:upstream_authentication_token] if params[:action] == 'create' || @repository&.yum?
       keys += [:ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token] if params[:action] == 'create' || @repository&.ansible_collection?
       keys += [:label, :content_type] if params[:action] == "create"
 
@@ -614,27 +616,31 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
       credential_value
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity,Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength
     def construct_repo_from_params(repo_params) # rubocop:disable Metrics/AbcSize
       root = @product.add_repo(repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                             :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
                                                             :checksum_type, :download_policy, :http_proxy_policy,
                                                             :metadata_expire).to_h.with_indifferent_access)
-      root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
-      if root.docker?
-        root.include_tags = repo_params.fetch(:include_tags, [])
-      end
-      root.exclude_tags = repo_params.fetch(:exclude_tags, ['*-source']) if root.docker?
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
       root.mirroring_policy = repo_params[:mirroring_policy] || Katello::RootRepository::MIRRORING_POLICY_CONTENT
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
       root.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
-      root.upstream_authentication_token = repo_params[:upstream_authentication_token] if repo_params.key?(:upstream_authentication_token)
-      root.ignorable_content = repo_params[:ignorable_content] if root.yum? && repo_params.key?(:ignorable_content)
       root.http_proxy_policy = repo_params[:http_proxy_policy] if repo_params.key?(:http_proxy_policy)
       root.http_proxy_id = repo_params[:http_proxy_id] if repo_params.key?(:http_proxy_id)
-      root.os_versions = repo_params.fetch(:os_versions, []) if root.yum?
-      root.retain_package_versions_count = repo_params[:retain_package_versions_count] if root.yum? && repo_params.key?(:retain_package_versions_count)
+
+      if root.yum?
+        root.upstream_authentication_token = repo_params[:upstream_authentication_token] if repo_params.key?(:upstream_authentication_token)
+        root.retain_package_versions_count = repo_params[:retain_package_versions_count] if repo_params.key?(:retain_package_versions_count)
+        root.ignorable_content = repo_params[:ignorable_content] if repo_params.key?(:ignorable_content)
+        root.os_versions = repo_params.fetch(:os_versions, [])
+      end
+
+      if root.docker?
+        root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
+        root.include_tags = repo_params.fetch(:include_tags, [])
+        root.exclude_tags = repo_params.fetch(:exclude_tags, ['*-source'])
+      end
 
       if root.generic?
         generic_remote_options = generic_remote_options_hash(repo_params)

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

@@ -29,7 +29,7 @@ module Katello
     param :with_custom, :bool, :required => false, :desc => N_("If true, return custom repository sets along with redhat repos. Will be ignored if repository_type is supplied.")
     param :activation_key_id, :number, :desc => N_("activation key identifier"), :required => false
     param :host_id, :number, :desc => N_("Id of the host"), :required => false
-    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions.")
+    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions."), deprecated: true, default: true
     param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the host's or activation key's content view version and lifecycle environment.")
     param :status, [:enabled, :disabled, :overridden],
                                   :desc => N_("Limit content to enabled / disabled / overridden"),
@@ -225,6 +225,7 @@ module Katello
 
     def setup_params
       return unless params[:id]
+      params[:content_access_mode_all] = true
       if params[:entity] == :activation_key
         params[:activation_key_id] ||= params[:id]
       else

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

@@ -1,42 +1,29 @@
 module Katello
   class Api::V2::SimpleContentAccessController < Api::V2::ApiController
-    before_action :find_organization
-
     resource_description do
       description "Red Hat subscriptions management platform."
       api_version 'v2'
     end
 
-    api :GET, "/organizations/:organization_id/simple_content_access/eligible",
-      N_("Check if the specified organization is eligible for Simple Content Access. %s") % sca_only_deprecation_text, deprecated: true
+    def render_sca_410_error
+      render_error 'custom_error', status: :gone,
+                                    locals: { message: N_('Simple Content Access is the only supported content access mode') }
+    end
+
     def eligible
-      ::Foreman::Deprecation.api_deprecation_warning(N_("This endpoint is deprecated and will be removed in Katello 4.12. All organizations are now eligible for Simple Content Access."))
-      eligible = @organization.simple_content_access_eligible?
-      render json: { simple_content_access_eligible: eligible }
+      render_sca_410_error
     end
 
-    api :GET, "/organizations/:organization_id/simple_content_access/status",
-      N_("Check if the specified organization has Simple Content Access enabled. %s") % sca_only_deprecation_text, deprecated: true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def status
-      status = @organization.simple_content_access?
-      render json: { simple_content_access: status }
+      render_sca_410_error
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/enable",
-      N_("Enable simple content access for a manifest"), deprecated: true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def enable
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
-      respond_for_async :resource => task
+      render_sca_410_error
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/disable",
-      N_("Disable simple content access for a manifest. %s") % sca_only_deprecation_text, deprecated: true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def disable
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
-      respond_for_async :resource => task
+      render_sca_410_error
     end
   end
 end

data/app/controllers/katello/concerns/api/v2/authorization.rb

@@ -49,7 +49,7 @@ module Katello
 
         # promote_or_remove_content_views_to_environments has a special relationship to promote_or_remove_content_views
         if path_to_authenticate["controller"] == "katello/api/v2/content_view_versions" &&
-            path_to_authenticate["action"].in?(["promote", "remove_from_environment", "remove", "republish_repositories"])
+            path_to_authenticate["action"].in?(["promote", "remove_from_environment", "remove", "republish_repositories", "verify_checksum"])
           missing_perms << ::Permission.find_by(name: "promote_or_remove_content_views_to_environments")
         end
         missing_perms

data/app/helpers/katello/subscription_mailer_helper.rb

@@ -13,7 +13,7 @@ module Katello
     end
 
     def start_report_task(days_from_now)
-      @report_template = ReportTemplate.find_by(name: "Subscription - Entitlement Report")
+      @report_template = ReportTemplate.find_by(name: "Subscription - General Report")
       template_input_id = @report_template.template_inputs.find_by_name("Days from Now").id.to_s
       params = { format: 'csv', template_id: @report_template.id, input_values: { template_input_id => { value: days_from_now} } }
       composer = ReportComposer.new(params)

data/app/jobs/create_manifest_expire_soon_warning_notifications.rb

@@ -0,0 +1,11 @@
+class CreateManifestExpireSoonWarningNotifications < ApplicationJob
+  def perform
+    Katello::UINotifications::Subscriptions::ManifestExpireSoonWarning.deliver!
+  ensure
+    self.class.set(:wait => 24.hours).perform_later
+  end
+
+  def humanized_name
+    _('Subscription Manifest expiration date check')
+  end
+end

data/app/lib/actions/candlepin/owner/regenerate_upstream_identity_cert.rb

@@ -0,0 +1,21 @@
+module Actions
+  module Candlepin
+    module Owner
+      class RegenerateUpstreamIdentityCert < Candlepin::Abstract
+        input_format do
+          param :organization_id
+          param :upstream
+        end
+
+        def run
+          organization = ::Organization.find(input[:organization_id])
+          output[:response] = organization.redhat_provider.owner_upstream_regenerate_identity_cert(input[:upstream])
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

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

@@ -52,7 +52,7 @@ module Actions
           notification = MailNotification[:proxy_sync_failure]
           proxy = SmartProxy.find(input.fetch(:smart_proxy, {})[:id])
           subjects = subjects(input[:options]).merge(smart_proxy: proxy)
-          notification.users.where(disabled: [nil, false], mail_enabled: true).each do |user|
+          notification.users.with_enabled_email.each do |user|
             notification.deliver(subjects.merge(user: user, task: task))
           end
         end

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

@@ -69,8 +69,13 @@ module Actions
         end
 
         def update_content_counts(_execution_plan)
-          smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
-          ::ForemanTasks.async_task(::Actions::Katello::CapsuleContent::UpdateContentCounts, smart_proxy)
+          if Setting[:automatic_content_count_updates]
+            smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
+            ::ForemanTasks.async_task(::Actions::Katello::CapsuleContent::UpdateContentCounts, smart_proxy)
+          else
+            Rails.logger.info "Skipping content counts update as automatic content count updates are disabled. To enable automatic content count updates, set the 'automatic_content_count_updates' setting to true.
+To update content counts manually, run the 'Update Content Counts' action."
+          end
         end
 
         def resource_locks

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

@@ -0,0 +1,75 @@
+module Actions
+  module Katello
+    module CapsuleContent
+      class VerifyChecksum < ::Actions::EntryAction
+        def humanized_name
+          _("Verify checksum for content on smart proxy")
+        end
+
+        def plan(smart_proxy, options = {})
+          input[:options] = options
+          action_subject(smart_proxy)
+          fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_primary?
+          subjects = subjects(options)
+          repair_options = options.merge(subjects)
+          environment = repair_options[:environment]
+          content_view = repair_options[:content_view]
+          check_cv_capsule_environments!(smart_proxy, content_view, environment)
+          repository = repair_options[:repository]
+          repos = repos_to_repair(smart_proxy, environment, content_view, repository)
+          repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
+            concurrence do
+              repo_batch.each do |repo|
+                if smart_proxy.pulp3_support?(repo)
+                  plan_action(Actions::Pulp3::CapsuleContent::VerifyChecksum,
+                              repo,
+                              smart_proxy)
+                end
+              end
+            end
+          end
+        end
+
+        def repos_to_repair(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
+            repositories
+          end
+        end
+
+        def check_cv_capsule_environments!(smart_proxy, content_view, environment)
+          cv_environments = content_view&.versions&.collect(&:environments)&.flatten
+          if cv_environments.present?
+            if environment.present? && !(cv_environments.pluck(:id).include? environment.id)
+              fail _("Content view '%{content_view}' is not attached to the environment.") % {content_view: content_view.name}
+            end
+            if (smart_proxy.lifecycle_environments.pluck(:id) & cv_environments.pluck(:id)).empty?
+              fail _("Content view '%{content_view}' is not attached to this capsule.") % {content_view: content_view.name}
+            end
+          end
+        end
+
+        def subjects(options = {})
+          environment_id = options.fetch(:environment_id, nil)
+          environment = ::Katello::KTEnvironment.find(environment_id) if environment_id
+
+          repository_id = options.fetch(:repository_id, nil)
+          repository = ::Katello::Repository.find(repository_id) if repository_id
+
+          content_view_id = options.fetch(:content_view_id, nil)
+          content_view = ::Katello::ContentView.find(content_view_id) if content_view_id
+
+          {content_view: content_view, environment: environment, repository: repository}
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ module Actions
         def notify_on_failure(_plan)
           notification = MailNotification[:content_view_promote_failure]
           view = ::Katello::ContentView.find(input.fetch(:content_view, {})[:id])
-          notification.users.where(disabled: [nil, false], mail_enabled: true).each do |user|
+          notification.users.with_enabled_email.each do |user|
             notification.deliver(user: user, content_view: view, task: task)
           end
         end

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

@@ -136,7 +136,7 @@ module Actions
         def notify_on_failure(_plan)
           notification = MailNotification[:content_view_publish_failure]
           view = ::Katello::ContentView.find(input.fetch(:content_view, {})[:id])
-          notification.users.where(disabled: [nil, false], mail_enabled: true).each do |user|
+          notification.users.with_enabled_email.each do |user|
             notification.deliver(user: user, content_view: view, task: task)
           end
         end

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

@@ -0,0 +1,29 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class VerifyChecksum < Actions::EntryAction
+        def plan(content_view_version)
+          action_subject(content_view_version.content_view)
+          plan_self(:version_id => content_view_version.id)
+          plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::VerifyChecksum, content_view_version.repositories) if content_view_version.repositories.any?
+        end
+
+        def run
+          #dummy run phase to save input and support humanized_name
+        end
+
+        def humanized_name
+          if input && input[:version_id]
+            version = ::Katello::ContentViewVersion.find_by(:id => input[:version_id])
+          end
+
+          if version
+            _("Verify checksum of repositories in %{name} %{version}") % {:name => version.content_view.name, :version => version.version}
+          else
+            _("Verify checksum of version repositories")
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -169,6 +169,7 @@ module Actions
           if @candlepin_attributes.key?(uuid)
             host.subscription_facet.candlepin_consumer.consumer_attributes = @candlepin_attributes[uuid]
             host.subscription_facet.import_database_attributes
+            host.subscription_facet.last_checkin = Time.now
             host.subscription_facet.save!
           end
         end

data/app/lib/actions/katello/host/update_content_view.rb

@@ -17,9 +17,9 @@ module Actions
 
         def humanized_name
           if input.try(:[], :hostname).nil?
-            _("Update for host")
+            _("Update content view environments for host")
           else
-            _("Update for host %s") % input[:hostname]
+            _("Update content view environments for host %s") % input[:hostname]
           end
         end
       end

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

@@ -16,10 +16,15 @@ module Actions
             repositories.each do |repo|
               plan_action(Katello::Repository::RefreshRepository, repo)
             end
-            plan_self
+            plan_self(:organization_name => organization.name)
           end
         end
 
+        def run
+          organization = ::Organization.find_by(name: input[:organization_name])
+          organization&.manifest_expiration_date(cached: false) # update organization.manifest_imported? value
+        end
+
         def failure_notification(plan)
           ::Katello::UINotifications::Subscriptions::ManifestDeleteError.deliver!(
             :subject => subject_organization,

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

@@ -27,6 +27,11 @@ module Actions
           end
         end
 
+        def run
+          organization = ::Organization.find_by(name: input[:organization_name])
+          organization&.manifest_expiration_date(cached: false) # update the date
+        end
+
         def failure_notification(plan)
           ::Katello::UINotifications::Subscriptions::ManifestImportError.deliver!(
             :subject => subject_organization,

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

@@ -21,6 +21,9 @@ module Actions
             upstream_update = plan_action(Candlepin::Owner::UpstreamUpdate,
                         { :organization_id => organization.id,
                           :upstream => upstream })
+            plan_action(Candlepin::Owner::RegenerateUpstreamIdentityCert,
+                        { :organization_id => organization.id,
+                          :upstream => upstream })
             export_action = plan_action(Candlepin::Owner::StartUpstreamExport,
                         { :organization_id => organization.id,
                           :upstream => upstream,