katello 4.11.1 → 4.12.0.rc2

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

@@ -260,6 +260,7 @@ module Katello
       User.current = User.anonymous_admin
       @host.update_candlepin_associations(rhsm_params)
       update_host_registered_through(@host, request.headers)
+      @host.refresh_statuses([::Katello::RhelLifecycleStatus])
       render :json => {:content => _("Facts successfully updated.")}, :status => :ok
     end
 

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

@@ -59,7 +59,7 @@ module Katello
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(ContentView)
     def index
-      content_view_includes = [:activation_keys, :content_view_versions,
+      content_view_includes = [:activation_keys, :content_view_versions, :content_view_components,
                                :environments, :organization, :repositories]
       respond(:collection => scoped_search(index_relation.distinct, :name, :asc, :includes => content_view_includes))
     end

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

@@ -88,9 +88,13 @@ module Katello
     def custom_index_relation(collection)
       applicable = ::Foreman::Cast.to_bool(params[:packages_restrict_applicable]) || params[:host_id]
       upgradable = ::Foreman::Cast.to_bool(params[:packages_restrict_upgradable])
+      not_installed = ::Foreman::Cast.to_bool(params[:packages_restrict_not_installed])
 
       if upgradable
         collection = collection.installable_for_hosts(@hosts)
+      elsif not_installed && params[:host_id]
+        host = @hosts.first
+        collection = Katello::Deb.apt_installable_for_host(host)
       elsif applicable
         collection = collection.applicable_to_hosts(@hosts)
       end

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

@@ -11,14 +11,26 @@ module Katello
 
     api :GET, "/hosts/:host_id/debs", N_("List deb packages installed on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
+    param :include_latest_upgradable, :boolean, :desc => N_("Also include the latest upgradable package version for each host package")
+    param :status, String, :desc => N_("Return only packages of a particular status (upgradable or up-to-date)"), :required => false
     param_group :search, Api::V2::ApiController
+    add_scoped_search_description_for(Katello::InstalledDeb)
     def index
       collection = scoped_search(index_relation, :name, :asc, :resource_class => ::Katello::InstalledDeb)
+      collection[:results] = HostDebPresenter.with_latest(collection[:results], @host) if ::Foreman::Cast.to_bool(params[:include_latest_upgradable])
       respond_for_index(:collection => collection)
     end
 
     def index_relation
-      @host.installed_debs
+      packages = @host.installed_debs
+      upgradable_packages = ::Katello::Deb.installable_for_hosts([@host]).select(:name)
+      if params[:status].present?
+        packages = case params[:status]
+                   when 'up-to-date' then packages.where.not(name: upgradable_packages)
+                   when 'upgradable' then packages.where(name: upgradable_packages)
+                   end
+      end
+      packages
     end
 
     def resource_class

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

@@ -170,6 +170,7 @@ module Katello
     param :content_overrides_search, Hash, :desc => N_("Content override search parameters") do
       param_group :search, Api::V2::ApiController
       param :enabled, :bool, :desc => N_("Set true to override to enabled; Set false to override to disabled.'"), :required => false
+      param :limit_to_env, :bool, :desc => N_("Limit actions to content in the host's environment."), :required => false
       param :remove, :bool, :desc => N_("Set true to remove an override and reset it to 'default'"), :required => false
     end
     def content_override
@@ -232,10 +233,22 @@ module Katello
 
     def find_content_overrides
       if !params.dig(:content_overrides_search, :search).nil?
+
         content_labels = ::Katello::Content.joins(:product_contents)
                             .where("#{Katello::ProductContent.table_name}.product_id": @host.organization.products.subscribable.enabled)
                             .search_for(params[:content_overrides_search][:search])
                             .pluck(:label)
+
+        if Foreman::Cast.to_bool(params.dig(:content_overrides_search, :limit_to_env))
+          env_content = ProductContentFinder.new(
+              :match_subscription => false,
+              :match_environment => true,
+              :consumable => @host.subscription_facet
+          ).product_content
+          env_content_labels = ::Katello::Content.find(env_content.pluck(:content_id)).pluck(:label)
+          content_labels &= env_content_labels
+        end
+
         @content_overrides = content_labels.map do |label|
           { content_label: label,
             value: Foreman::Cast.to_bool(params[:content_overrides_search][:enabled]),

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

@@ -80,11 +80,9 @@ module Katello
     param :organization, Hash do
       param :label, String, :required => false
     end
-    param :simple_content_access, :bool, :desc => N_('Whether to turn on Simple Content Access for the organization.'), :required => false, :default => true, deprecated: true
     def create
       @organization = Organization.new(resource_params)
-      sca = params.key?(:simple_content_access) ? ::Foreman::Cast.to_bool(params[:simple_content_access]) : true
-      creator = ::Katello::OrganizationCreator.new(@organization, sca: sca)
+      creator = ::Katello::OrganizationCreator.new(@organization)
       creator.create!
       @organization.reload
       # @taxonomy instance variable is necessary for foreman side

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

@@ -343,7 +343,6 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
 
     api :POST, "/repositories/:id/sync", N_("Sync a repository")
     param :id, :number, :required => true, :desc => N_("repository ID")
-    param :source_url, String, :desc => N_("temporarily override feed URL for sync"), :required => false
     param :incremental, :bool, :desc => N_("perform an incremental import"), :required => false
     param :skip_metadata_check, :bool, :desc => N_("Force sync even if no upstream changes are detected. Only used with yum or deb repositories."), :required => false
     param :validate_contents, :bool, :desc => N_("Force a sync and validate the checksums of all content. Only used with yum repositories."), :required => false
@@ -352,15 +351,10 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
       sync_options = {
         :skip_metadata_check => ::Foreman::Cast.to_bool(params[:skip_metadata_check]),
         :validate_contents => ::Foreman::Cast.to_bool(params[:validate_contents]),
-        :incremental => ::Foreman::Cast.to_bool(params[:incremental]),
-        :source_url => params[:source_url]
+        :incremental => ::Foreman::Cast.to_bool(params[:incremental])
       }
 
-      if params[:source_url].present? && params[:source_url] !~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
-        fail HttpErrors::BadRequest, _("source URL is malformed")
-      end
-
-      if params[:source_url].blank? && @repository.url.blank?
+      if @repository.url.blank?
         fail HttpErrors::BadRequest, _("attempted to sync without a feed URL")
       end
 

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

@@ -29,7 +29,6 @@ module Katello
           param :registration_command, Hash do
             param :activation_key, String, desc: N_('Activation key for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. For multiple keys use `activation_keys` param instead.'), deprecated: true
             param :activation_keys, Array, desc: N_('Activation keys for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. Required only if host group has no activation keys.')
-            param :lifecycle_environment_id, :number, required: false, desc: N_('Lifecycle environment for the host.')
             param :force, :bool, required: false, desc: N_('Clear any previous registration and run subscription-manager with --force.')
             param :ignore_subman_errors, :bool, required: false, desc: N_('Ignore subscription-manager errors for `subscription-manager register` command')
           end

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

@@ -20,6 +20,10 @@ module Katello
       included do
         prepend Overrides
 
+        def included_associations(include = [])
+          [:host_traces] + super
+        end
+
         def update_multiple_taxonomies(type)
           if type == :organization
             new_org_id = params.dig(type, 'id')
@@ -59,11 +63,11 @@ module Katello
                          .preload(:subscription_facet, :host_statuses, :operatingsystem,
                                   :applicable_rpms, :content_view_environments)
               csv_response(@hosts,
-                [:name, :subscription_status_label, 'content_facet.installable_security_errata_count',
+                [:name, 'content_facet.installable_security_errata_count',
                  'content_facet.installable_bugfix_errata_count', 'content_facet.installable_enhancement_errata_count',
                  'content_facet.upgradable_rpm_count', :operatingsystem, :content_view_environment_names,
                  'subscription_facet.registered_at', 'subscription_facet.last_checkin'],
-                ['Name', 'Subscription Status', 'Installable Updates - Security',
+                ['Name', 'Installable Updates - Security',
                  'Installable Updates - Bug Fixes', 'Installable Updates - Enhancements',
                  'Installable Updates - Package Count', 'OS', 'Content View Environments',
                  'Registered', 'Last Checkin'])
@@ -91,7 +95,7 @@ module Katello
                                       .distinct
 
           if Katello.with_remote_execution?
-            template_id = JobTemplate.find_by(name: 'Configure host for new content source')&.id
+            template_id = RemoteExecutionFeature.feature!(:katello_change_content_source).job_template_id
             job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts.map { |h| h[:id] }) if template_id
           end
 

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

@@ -24,9 +24,7 @@ module Katello
           if taxonomy_class == Organization
             begin
               @taxonomy = Organization.new(resource_params)
-              sca = ::Foreman::Cast.to_bool(params[:simple_content_access])
-              ::Foreman::Deprecation.api_deprecation_warning(N_("Simple Content Access will be required for all organizations in Katello 4.12."))
-              ::Katello::OrganizationCreator.new(@taxonomy, sca: sca).create!
+              ::Katello::OrganizationCreator.new(@taxonomy).create!
               @taxonomy.reload
               switch_taxonomy
               if @count_nil_hosts > 0
@@ -45,20 +43,6 @@ module Katello
         end
       end
 
-      def update
-        return if params[:simple_content_access].nil?
-        sca_param = ::Foreman::Cast.to_bool(params[:simple_content_access])
-        ::Foreman::Deprecation.api_deprecation_warning("Simple Content Access will be required for all organizations in Katello 4.12.")
-        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
-        super
-      end
-
       included do
         prepend Overrides
       end

data/app/helpers/katello/concerns/dashboard_helper_extensions.rb

@@ -9,26 +9,6 @@ module Katello
         host_query.size
       end
 
-      def partial_consumer_count
-        host_query.search_for("subscription_status = partial").size
-      end
-
-      def valid_consumer_count
-        host_query.search_for("subscription_status = valid").size
-      end
-
-      def invalid_consumer_count
-        host_query.search_for("subscription_status = invalid").size
-      end
-
-      def unknown_consumer_count
-        host_query.search_for("subscription_status = unknown or (null? subscription_uuid)").size
-      end
-
-      def unsubscribed_hypervisor_count
-        host_query.search_for("subscription_status = unsubscribed_hypervisor").size
-      end
-
       def removed_widgets
         widgets = super
 

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

@@ -13,7 +13,7 @@ module Actions
         def plan(content_view, description = "", options = {importing: false, syncable: false}) # rubocop:disable Metrics/PerceivedComplexity
           action_subject(content_view)
 
-          content_view.check_ready_to_publish!(options.slice(:importing, :syncable))
+          content_view.check_ready_to_publish!(**options.slice(:importing, :syncable))
           unless options[:importing] || options[:syncable]
             ::Katello::Util::CandlepinRepositoryChecker.check_repositories_for_publish!(content_view)
           end
@@ -57,7 +57,7 @@ module Actions
             separated_repo_map = separated_repo_mapping(repository_mapping, content_view.solve_dependencies)
 
             if options[:importing]
-              handle_import(version, options.slice(:path, :metadata))
+              handle_import(version, **options.slice(:path, :metadata))
             elsif separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
               plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
             end
@@ -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
@@ -203,7 +203,7 @@ module Actions
 
         def handle_import(version, path:, metadata:)
           sequence do
-            plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)
+            plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, { path: path, metadata: metadata })
             concurrence do
               version.importable_repositories.pluck(:id).each do |id|
                 # need to force full_indexing for these version repositories

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

@@ -2,14 +2,14 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateProducts < Actions::Base
-        def plan(import:)
+        def plan(opts = {})
           helper = ::Katello::Pulp3::ContentViewVersion::ImportableProducts.
-                      new(organization: import.organization,
-                          metadata_products: import.metadata_map.products)
+                      new(organization: opts[:import].organization,
+                          metadata_products: opts[:import].metadata_map.products)
           helper.generate!
           concurrence do
             helper.creatable.each do |product|
-              plan_action(::Actions::Katello::Product::Create, product[:product], import.organization)
+              plan_action(::Actions::Katello::Product::Create, product[:product], opts[:import].organization)
             end
             helper.updatable.each do |product|
               plan_action(::Actions::Katello::Product::Update, product[:product], product[:options])

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

@@ -2,12 +2,12 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRedhatRepositories < Actions::Base
-        def plan(import:, path:)
+        def plan(opts = {})
           helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
-            organization: import.organization,
-            metadata_repositories: import.metadata_map.repositories.select { |r| r.redhat },
-            syncable_format: import.metadata_map.syncable_format?,
-            path: path
+            organization: opts[:import].organization,
+            metadata_repositories: opts[:import].metadata_map.repositories.select { |r| r.redhat },
+            syncable_format: opts[:import].metadata_map.syncable_format?,
+            path: opts[:path]
           )
           helper.generate!
 

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

@@ -2,12 +2,12 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRepositories < Actions::Base
-        def plan(import:, path:)
+        def plan(opts = {})
           helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
-            organization: import.organization,
-            metadata_repositories: import.metadata_map.repositories.select { |r| !r.redhat },
-            syncable_format: import.metadata_map.syncable_format?,
-            path: path
+            organization: opts[:import].organization,
+            metadata_repositories: opts[:import].metadata_map.repositories.select { |r| !r.redhat },
+            syncable_format: opts[:import].metadata_map.syncable_format?,
+            path: opts[:path]
           )
           helper.generate!
 

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

@@ -2,45 +2,46 @@ module Actions
   module Katello
     module ContentViewVersion
       class Import < Actions::EntryAction
-        def plan(organization:, path:, metadata:)
-          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: metadata)
+        def plan(opts = {})
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: opts[:metadata])
 
           import = ::Katello::Pulp3::ContentViewVersion::Import.new(
-            organization: organization,
+            organization: opts[:organization],
             metadata_map: metadata_map,
-            path: path,
+            path: opts[:path],
             smart_proxy: SmartProxy.pulp_primary!
           )
 
           import.check!
 
           gpg_helper = ::Katello::Pulp3::ContentViewVersion::ImportGpgKeys.
-                          new(organization: organization,
+                          new(organization: opts[:organization],
                               metadata_gpg_keys: metadata_map.gpg_keys)
           gpg_helper.import!
 
           sequence do
-            plan_action(AutoCreateProducts, import: import)
-            plan_action(AutoCreateRepositories, import: import, path: path)
-            plan_action(AutoCreateRedhatRepositories, import: import, path: path)
+            plan_action(AutoCreateProducts, { import: import })
+            plan_action(AutoCreateRepositories, { import: import, path: opts[:path] })
+            plan_action(AutoCreateRedhatRepositories, { import: import, path: opts[:path] })
 
             if metadata_map.syncable_format?
               plan_action(::Actions::BulkAction,
                     ::Actions::Katello::Repository::Sync,
                     import.intersecting_repos_library_and_metadata.exportable(format: metadata_map.format),
-                    skip_candlepin_check: true
+                    { skip_candlepin_check: true }
                     )
             end
 
             if import.content_view
-              plan_action(ResetContentViewRepositoriesFromMetadata, import: import)
+              plan_action(ResetContentViewRepositoriesFromMetadata, { import: import })
               plan_action(::Actions::Katello::ContentView::Publish, import.content_view, metadata_map.content_view_version.description,
-                            path: path,
-                            metadata: metadata,
+                          { path: opts[:path],
+                            metadata: opts[:metadata],
                             importing: !metadata_map.syncable_format?,
                             syncable: metadata_map.syncable_format?,
                             major: metadata_map.content_view_version.major,
-                            minor: metadata_map.content_view_version.minor)
+                            minor: metadata_map.content_view_version.minor
+                          })
               plan_self(content_view_id: import.content_view.id)
             end
           end

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

@@ -2,11 +2,11 @@ module Actions
   module Katello
     module ContentViewVersion
       class ImportLibrary < Actions::EntryAction
-        def plan(organization, path:, metadata:)
+        def plan(organization, opts = {})
           action_subject(organization)
-          plan_action(::Actions::Katello::ContentViewVersion::Import, organization: organization,
-                                                                      path: path,
-                                                                      metadata: metadata)
+          plan_action(::Actions::Katello::ContentViewVersion::Import, { organization: organization,
+                                                                        path: opts[:path],
+                                                                        metadata: opts[:metadata] })
         end
 
         def humanized_name

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

@@ -2,13 +2,13 @@ module Actions
   module Katello
     module ContentViewVersion
       class ImportRepository < Actions::EntryAction
-        def plan(organization, path:, metadata:)
+        def plan(organization, opts = {})
           action_subject(organization)
           sequence do
             plan_action(::Actions::Katello::ContentViewVersion::Import,
                                             organization: organization,
-                                            path: path,
-                                            metadata: metadata)
+                                            path: opts[:path],
+                                            metadata: opts[:metadata])
           end
         end
 

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

@@ -2,8 +2,8 @@ module Actions
   module Katello
     module ContentViewVersion
       class ResetContentViewRepositoriesFromMetadata < Actions::Base
-        def plan(import:)
-          import.reset_content_view_repositories!
+        def plan(opts = {})
+          opts[:import].reset_content_view_repositories!
         end
       end
     end

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

@@ -170,7 +170,6 @@ module Actions
             host.subscription_facet.candlepin_consumer.consumer_attributes = @candlepin_attributes[uuid]
             host.subscription_facet.import_database_attributes
             host.subscription_facet.save!
-            host.subscription_facet.update_subscription_status(@candlepin_attributes[uuid].try(:[], :entitlementStatus))
           end
         end
 

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

@@ -10,7 +10,7 @@ module Actions
           action_subject(organization)
 
           sequence do
-            plan_action(Candlepin::Owner::DestroyImports, label: organization.label)
+            plan_action(Candlepin::Owner::DestroyImports, { label: organization.label })
 
             repositories = ::Katello::Repository.in_default_view.in_product(::Katello::Product.redhat.in_org(organization))
             repositories.each do |repo|

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

@@ -19,26 +19,26 @@ module Actions
               :organization_name => organization.name
             )
             upstream_update = plan_action(Candlepin::Owner::UpstreamUpdate,
-                        :organization_id => organization.id,
-                        :upstream => upstream)
+                        { :organization_id => organization.id,
+                          :upstream => upstream })
             export_action = plan_action(Candlepin::Owner::StartUpstreamExport,
-                        :organization_id => organization.id,
-                        :upstream => upstream,
-                        :path => path,
-                        :dependency => upstream_update.output)
+                        { :organization_id => organization.id,
+                          :upstream => upstream,
+                          :path => path,
+                          :dependency => upstream_update.output })
             retrieved_export = plan_action(Candlepin::Owner::RetrieveUpstreamExport,
-                        :export_id => export_action.output[:task]['resultData']['exportId'],
-                        :organization_id => organization.id,
-                        :upstream => upstream,
-                        :path => path,
-                        :dependency => export_action.output)
+                        { :export_id => export_action.output[:task]['resultData']['exportId'],
+                          :organization_id => organization.id,
+                          :upstream => upstream,
+                          :path => path,
+                          :dependency => export_action.output })
             owner_import = plan_action(Candlepin::Owner::Import,
-                        :label => organization.label,
-                        :path => path,
-                        :dependency => retrieved_export.output)
+                        { :label => organization.label,
+                          :path => path,
+                          :dependency => retrieved_export.output })
             import_products = plan_action(Candlepin::Owner::ImportProducts,
-              :organization_id => organization.id,
-              :dependency => owner_import.output)
+              { :organization_id => organization.id,
+                :dependency => owner_import.output })
             plan_action(Katello::Organization::EnvironmentContentsRefresh,
               organization)
             if manifest_update

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

@@ -21,13 +21,11 @@ module Actions
         def plan(repo, options = {})
           action_subject(repo)
 
-          source_url = options.fetch(:source_url, nil)
           validate_contents = options.fetch(:validate_contents, false)
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && (repo.yum? || repo.deb?))
           generate_applicability =  options.fetch(:generate_applicability, repo.yum? || repo.deb?)
 
           validate_repo!(repo: repo,
-                        source_url: source_url,
                         skip_metadata_check: skip_metadata_check,
                         skip_candlepin_check: options.fetch(:skip_candlepin_check, false))
 
@@ -82,8 +80,8 @@ module Actions
           end
         end
 
-        def validate_repo!(repo:, source_url:, skip_metadata_check:, skip_candlepin_check:)
-          fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
+        def validate_repo!(repo:, skip_metadata_check:, skip_candlepin_check:)
+          fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank?
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum/deb repositories.") if skip_metadata_check && !repo.yum? && !repo.deb?
           fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository is not a library instance repository.") unless repo.library_instance?
           ::Katello::Util::CandlepinRepositoryChecker.check_repository_for_sync!(repo) if repo.yum? && !skip_candlepin_check
@@ -102,7 +100,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/pulp3/orchestration/content_view_version/export.rb

@@ -18,30 +18,35 @@ module Actions
             param :export_path, String
           end
 
-          def plan(content_view_version:, destination_server: nil,
-                   chunk_size: nil, from_history: nil,
-                   validate_incremental: true,
-                   fail_on_missing_content: false,
-                   format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
+          def plan(opts = {})
+            options = {
+              content_view_version: nil, destination_server: nil,
+              chunk_size: nil, from_history: nil,
+              validate_incremental: true,
+              fail_on_missing_content: false,
+              format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
+            }.merge(opts)
+            content_view_version = options[:content_view_version]
+            format = options[:format]
             smart_proxy = SmartProxy.pulp_primary!
-            from_content_view_version = from_history&.content_view_version
+            from_content_view_version = options[:from_history]&.content_view_version
             export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
                 smart_proxy: smart_proxy,
                 content_view_version: content_view_version,
-                destination_server: destination_server,
+                destination_server: options[:destination_server],
                 from_content_view_version: from_content_view_version,
                 format: format)
-            export_service.validate!(fail_on_missing_content: fail_on_missing_content,
-                                     validate_incremental: validate_incremental,
-                                     chunk_size: chunk_size)
+            export_service.validate!(fail_on_missing_content: options[:fail_on_missing_content],
+                                     validate_incremental: options[:validate_incremental],
+                                     chunk_size: options[:chunk_size])
 
             if format == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
               sequence do
                 export_output = plan_action(SyncableExport,
                           content_view_version: content_view_version,
-                          from_content_view_version: from_history&.content_view_version,
+                          from_content_view_version: options[:from_history]&.content_view_version,
                           smart_proxy: smart_proxy,
-                          destination_server: destination_server).output
+                          destination_server: options[:destination_server]).output
                 plan_self(export_history_id: export_output[:export_history_id],
                           export_path: export_output[:export_path])
               end
@@ -52,14 +57,14 @@ module Actions
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
                                           content_view_version_id: content_view_version.id,
                                           smart_proxy_id: smart_proxy.id,
-                                          destination_server: destination_server,
+                                          destination_server: options[:destination_server],
                                           format: format).output
 
               plan_action(::Actions::Pulp3::ContentViewVersion::Export,
                           content_view_version_id: content_view_version.id,
                           smart_proxy_id: smart_proxy.id,
                           exporter_data: action_output[:exporter_data],
-                          chunk_size: chunk_size,
+                          chunk_size: options[:chunk_size],
                           from_content_view_version_id: from_content_view_version&.id,
                           format: format)
 
@@ -70,7 +75,7 @@ module Actions
                   pulp_href: action_output[:exporter_data][:pulp_href],
                   content_view_version_id: content_view_version.id,
                   from_content_view_version_id: from_content_view_version&.id,
-                  destination_server: destination_server,
+                  destination_server: options[:destination_server],
                   format: format
               ).output