katello 4.12.0.rc3 → 4.13.0.rc1

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/concerns/dashboard_helper_extensions.rb

@@ -8,16 +8,6 @@ module Katello
       def total_host_count
         host_query.size
       end
-
-      def removed_widgets
-        widgets = super
-
-        if Organization.current&.simple_content_access?
-          widgets.reject! { |widget| ::Widget.singleton_class::SUBSCRIPTION_TEMPLATES.include? widget[:template] }
-        end
-
-        widgets
-      end
     end
   end
 end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -72,6 +72,10 @@ module Katello
     def fetch_lifecycle_environment(host_or_hostgroup, options = {})
       return host_or_hostgroup.single_lifecycle_environment if host_or_hostgroup.try(:single_lifecycle_environment)
       return host_or_hostgroup.lifecycle_environment if host_or_hostgroup.try(:lifecycle_environment)
+      if host_or_hostgroup.is_a?(::Hostgroup) && host_or_hostgroup.content_facet.present?
+        # to handle cloned hostgroups that are new records
+        return host_or_hostgroup.content_facet.lifecycle_environment
+      end
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.lifecycle_environment if selected_host_group.present?
     end
@@ -79,12 +83,20 @@ module Katello
     def fetch_content_view(host_or_hostgroup, options = {})
       return host_or_hostgroup.single_content_view if host_or_hostgroup.try(:single_content_view)
       return host_or_hostgroup.content_view if host_or_hostgroup.try(:content_view)
+      if host_or_hostgroup.is_a?(::Hostgroup) && host_or_hostgroup.content_facet.present?
+        # to handle cloned hostgroups that are new records
+        return host_or_hostgroup.content_facet.content_view
+      end
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_view if selected_host_group.present?
     end
 
-    def fetch_content_source(host, options = {})
-      return host.content_source if host.try(:content_source_id)
+    def fetch_content_source(host_or_hostgroup, options = {})
+      return host_or_hostgroup.content_source if host_or_hostgroup.content_source_id&.present? && host_or_hostgroup.persisted?
+      if host_or_hostgroup.is_a?(::Hostgroup) && host_or_hostgroup.content_facet.present?
+        # to handle cloned hostgroups that are new records
+        return host_or_hostgroup.content_facet.content_source
+      end
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_source if selected_host_group.present?
     end

data/app/helpers/katello/katello_urls_helper.rb

@@ -37,11 +37,36 @@ module Katello
       "#{prefix}/pub/#{config}"
     end
 
-    apipie :method, 'Generates an absolute path to the file' do
+    apipie :method, 'Generates an absolute path to the file for liveimg kickstart templates' do
       required :content_path, String, desc: "Relative path to the file or it's name"
       optional :schema, String, desc: 'Optional URL schema for the content source', default: 'http'
       optional :content_type, String, desc: 'Content type', default: 'repos'
       returns String, desc: 'Absolute path to a file'
     end
+    def repository_url(content_path, _content_type = nil, schema = 'http')
+      return content_path if content_path =~ %r|^([\w\-\+]+)://|
+      url = if @host.content_source
+              "#{schema}://#{@host.content_source.hostname}"
+            else
+              foreman_settings_url(schema)
+            end
+      content_path = content_path.sub(%r|^/|, '')
+
+      lifecycle_environment = nil
+      if @host.default_environment?
+        # Don't update the content_path if the host is using the default org view / library
+        lifecycle_environment = ::Katello::KTEnvironment.library.find_by(organization_id: @host.organization_id)
+      elsif !@host.single_content_view_environment?
+        fail ::Katello::Errors::MultiEnvironmentNotSupportedError,
+          "Host #{@host.name} must be subscribed to only a single content view & environment or subscribe to the default organization content view for liveimg provisioning."
+      else
+        lifecycle_environment = @host.single_lifecycle_environment
+        content_path = [@host.single_content_view.label, content_path].join('/')
+      end
+
+      path = ::Katello::Repository.repo_path_from_content_path(
+        lifecycle_environment, content_path)
+      "#{url}/pulp/content/#{path}"
+    end
   end
 end

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

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

@@ -1,8 +1,10 @@
 module Actions
   module Katello
     module Repository
-      class MetadataGenerate < Actions::Base
+      class MetadataGenerate < Actions::EntryAction
         def plan(repository, options = {})
+          action_subject(repository)
+          repository.check_ready_to_act!
           source_repository = options.fetch(:source_repository, nil)
           source_repository ||= repository.target_repository if repository.link?
           smart_proxy = options.fetch(:smart_proxy, SmartProxy.pulp_primary)
@@ -15,6 +17,10 @@ module Actions
                         :source_repository => source_repository,
                         :matching_content => matching_content)
         end
+
+        def resource_locks
+          :link
+        end
       end
     end
   end

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

@@ -5,6 +5,7 @@ module Actions
         include Dynflow::Action::WithSubPlans
 
         def plan(repository, content_units, options = {})
+          repository.check_ready_to_act!
           sync_capsule = options.fetch(:sync_capsule, true)
           if repository.redhat?
             fail _("Cannot remove content from a non-custom repository")

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

@@ -20,6 +20,7 @@ module Actions
         #   of Katello and we just need to finish the rest of the orchestration
         def plan(repo, options = {})
           action_subject(repo)
+          repo.check_ready_to_act!
 
           validate_contents = options.fetch(:validate_contents, false)
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && (repo.yum? || repo.deb?))
@@ -100,7 +101,7 @@ module Actions
         def notify_on_failure(_plan)
           notification = MailNotification[:repository_sync_failure]
           repo = ::Katello::Repository.find(input.fetch(:repository, {})[: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, repo: repo, task: task)
           end
         end

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

@@ -8,6 +8,7 @@ module Actions
       class UploadFiles < Actions::EntryAction
         def plan(repository, files, content_type = nil, options = {})
           action_subject(repository)
+          repository.check_ready_to_act!
           repository.clear_smart_proxy_sync_histories
           tmp_files = prepare_tmp_files(files)
 

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

@@ -0,0 +1,27 @@
+module Actions
+  module Pulp3
+    module CapsuleContent
+      class VerifyChecksum < Pulp3::AbstractAsyncTask
+        def plan(repository, smart_proxy)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.repair
+        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
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/content_view_version/export_repository.rb

@@ -3,26 +3,24 @@ module Actions
     module Orchestration
       module ContentViewVersion
         class ExportRepository < Actions::EntryAction
-          def plan(repository,
-                    chunk_size: nil,
-                    from_history: nil,
-                    format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
+          def plan(repository, opts = {})
+            opts[:format] ||= ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
             action_subject(repository)
             validate_repositories_immediate!(repository)
-            validate_export_types!(repository, format)
+            validate_export_types!(repository, opts[:format])
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
                                                                            repository: repository,
                                                                            create_by_default: true,
-                                                                           format: format)
+                                                                           format: opts[:format])
             content_view.update!(repository_ids: [repository.library_instance_or_self.id])
 
             sequence do
               publish_action = plan_action(::Actions::Katello::ContentView::Publish, content_view, '')
               export_action = plan_action(Actions::Katello::ContentViewVersion::Export,
                                           content_view_version: publish_action.version,
-                                          chunk_size: chunk_size,
-                                          from_history: from_history,
-                                          format: format)
+                                          chunk_size: opts[:chunk_size],
+                                          from_history: opts[:from_history],
+                                          format: opts[:format])
               plan_self(export_action_output: export_action.output)
             end
           end

data/app/lib/actions/pulp3/orchestration/content_view_version/syncable_export.rb

@@ -16,10 +16,11 @@ module Actions
             param :export_history_id, Integer
           end
 
-          def plan(content_view_version:,
-                   smart_proxy:,
-                   destination_server:,
-                   from_content_view_version:)
+          def plan(opts = {})
+            content_view_version = opts[:content_view_version]
+            smart_proxy = opts[:smart_proxy]
+            destination_server = opts[:destination_server]
+            from_content_view_version = opts[:from_content_view_version]
             format = ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
             sequence do
               export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -216,9 +216,14 @@ module Katello
         keyword :includes, Array, of: [String, Symbol], desc: 'An array of associations represented by strings or symbols, to be included in the SQL query. The list can be extended
           from plugins and can not be fully documented here. Most used associations are :subscription, :products, :organization', default: nil
         returns array_of: 'Pool', desc: 'The collection that can be iterated over using each_record'
+        keyword :expiring_in_days, String, desc: "Return subscriptions expiring in the given number of days. Leave blank to return all subscriptions.", default: nil
       end
-      def load_pools(search: '', includes: nil)
-        load_resource(klass: Pool.readable, search: search, permission: nil, includes: includes)
+      def load_pools(search: '', includes: nil, expiring_in_days: nil)
+        pools = Pool.readable
+        if expiring_in_days
+          pools = pools.expiring_in_days(expiring_in_days)
+        end
+        load_resource(klass: pools, search: search, permission: nil, includes: includes)
       end
 
       apipie :method, 'Returns the last time the host checked in via RHSM' do

data/app/lib/katello/errors.rb

@@ -10,6 +10,10 @@ module Katello
 
     class RegistrationError < StandardError; end
 
+    class InvalidRepositoryTypeError < StandardError; end
+
+    class MultiEnvironmentNotSupportedError < StandardError; end
+
     # unauthorized access
     class SecurityViolation < StandardError; end
 

data/app/lib/katello/http_resource.rb

@@ -38,6 +38,7 @@ module Katello
       get: Net::HTTP::Get,
       post: Net::HTTP::Post,
       put: Net::HTTP::Put,
+      patch: Net::HTTP::Patch,
       delete: Net::HTTP::Delete
     }.freeze
 
@@ -84,7 +85,11 @@ module Katello
       def issue_request(method:, path:, headers: {}, payload: nil)
         logger.debug("Resource #{method.upcase} request: #{path}")
         logger.debug "Headers: #{headers.to_json}"
-        logger.debug "Body: #{filter_sensitive_data(payload.to_json)}"
+        begin
+          logger.debug "Body: #{filter_sensitive_data(payload.to_json)}"
+        rescue JSON::GeneratorError, Encoding::UndefinedConversionError
+          logger.debug "Body: Error: could not render payload as json"
+        end
 
         client = rest_client(REQUEST_MAP[method], method, path)
         args = [method, payload, headers].compact

data/app/lib/katello/resources/candlepin/consumer.rb

@@ -7,7 +7,7 @@ module Katello
         class << self
           def all_uuids
             cp_consumers = Organization.all.map do |org|
-              ::Katello::Resources::Candlepin::Consumer.get('owner' => org.label, :include_only => [:uuid])
+              ::Katello::Resources::Candlepin::Consumer.get('owner' => org.label, :include_only => [:uuid], :sort_by => "uuid")
             end
             cp_consumers.flatten!
             cp_consumers.map { |consumer| consumer["uuid"] }

data/app/lib/katello/resources/candlepin/upstream_consumer.rb

@@ -40,19 +40,31 @@ module Katello
             raise ::Katello::Errors::UpstreamEntitlementGone
           end
 
-          def get_export(url, client_cert, client_key, ca_file)
+          def start_upstream_export(url, client_cert, client_key, ca_file)
             logger.debug "Sending GET request to upstream Candlepin: #{url}"
-            return resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).get
+            resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).get
           rescue RestClient::Exception => e
             raise e
           end
 
+          alias_method :retrieve_upstream_export, :start_upstream_export
+
           def update(url, client_cert, client_key, ca_file, attributes)
             logger.debug "Sending PUT request to upstream Candlepin: #{url} #{attributes.to_json}"
-            return resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).put(attributes.to_json,
-                                                                       'accept' => 'application/json',
-                                                                       'accept-language' => I18n.locale,
-                                                                       'content-type' => 'application/json')
+            resource(
+              url: url,
+              client_cert: client_cert,
+              client_key: client_key,
+              ca_file: ca_file).put(
+                attributes.to_json,
+                'accept' => 'application/json',
+                'accept-language' => I18n.locale,
+                'content-type' => 'application/json')
+          end
+
+          def regenerate_upstream_identity(url, client_cert, client_key, ca_file)
+            logger.debug "Sending POST request to upstream Candlepin: #{url}"
+            resource(url: url, client_cert: client_cert, client_key: client_key, ca_file: ca_file).post(nil)
           end
 
           def bind_entitlement(**pool)

data/app/lib/katello/resources/candlepin/upstream_job.rb

@@ -12,7 +12,7 @@ module Katello
 
           def get(id, upstream)
             url = API_URL
-            response = Resources::Candlepin::UpstreamConsumer.get_export("#{url}#{path(id)}", upstream['idCert']['cert'],
+            response = Resources::Candlepin::UpstreamConsumer.start_upstream_export("#{url}#{path(id)}", upstream['idCert']['cert'],
               upstream['idCert']['key'], nil)
             job = JSON.parse(response)
             job.with_indifferent_access