katello 4.2.1 → 4.3.0.rc1

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

@@ -3,6 +3,12 @@ module Katello
     include Katello::Concerns::FilteredAutoCompleteSearch
     include Katello::Concerns::Api::V2::HostErrataExtensions
 
+    TYPES_FROM_PARAMS = {
+      bugfix: Katello::Erratum::BUGZILLA, # ['bugfix', 'recommended']
+      security: Katello::Erratum::SECURITY, # ['security']
+      enhancement: Katello::Erratum::ENHANCEMENT # ['enhancement', 'optional']
+    }.freeze
+
     before_action :find_host, only: :index
     before_action :find_host_editable, except: :index
     before_action :find_errata_ids, only: :apply
@@ -35,11 +41,12 @@ module Katello
     param :host_id, :number, :desc => N_("UUID of the content host"), :required => true
     param :content_view_id, :number, :desc => N_("Calculate Applicable Errata based on a particular Content View"), :required => false
     param :environment_id, :number, :desc => N_("Calculate Applicable Errata based on a particular Environment"), :required => false
+    param :include_applicable, :bool, :desc => N_("Return errata that are applicable to this host. Defaults to false)"), :required => false
+    param :type, String, :desc => N_("Return only errata of a particular type (security, bugfix, enhancement)"), :required => false
+    param :severity, String, :desc => N_("Return only errata of a particular severity (None, Low, Moderate, Important, Critical)"), :required => false
     param_group :search, Api::V2::ApiController
     def index
-      if (params[:content_view_id] && params[:environment_id].nil?) || (params[:environment_id] && params[:content_view_id].nil?)
-        fail _("Either both parameters 'content_view_id' and 'environment_id' should be specified or neither should be specified")
-      end
+      validate_index_params!
 
       collection = scoped_search(index_relation, 'updated', 'desc', :resource_class => Erratum, :includes => [:cves])
 
@@ -79,22 +86,44 @@ module Katello
 
     protected
 
+    def total_selectable(query)
+      if ::Foreman::Cast.to_bool(params[:include_applicable])
+        query.where(:id => @host.content_facet.installable_errata).count
+      else
+        query.count
+      end
+    end
+
     def index_relation
       relation = Katello::Erratum.none
       if @host.content_facet
         relation = @host.content_facet.installable_errata(@environment, @content_view)
       end
+      if params[:type].present?
+        relation = relation.where(:errata_type => TYPES_FROM_PARAMS[params[:type].to_sym])
+      end
+      if params[:severity].present?
+        relation = relation.where(:severity => params[:severity])
+      end
       relation
     end
 
     private
 
     def find_content_view
-      @content_view = ContentView.readable.find(params[:content_view_id]) if params[:content_view_id]
+      @content_view = if ::Foreman::Cast.to_bool(params[:include_applicable])
+                        @host.organization.default_content_view
+                      elsif params[:content_view_id]
+                        ContentView.readable.find(params[:content_view_id])
+                      end
     end
 
     def find_environment
-      @environment = KTEnvironment.readable.find(params[:environment_id]) if params[:environment_id]
+      @environment = if ::Foreman::Cast.to_bool(params[:include_applicable])
+                       @host.organization.library
+                     elsif params[:environment_id]
+                       KTEnvironment.readable.find(params[:environment_id])
+                     end
     end
 
     def find_host
@@ -118,5 +147,17 @@ module Katello
         @errata_ids = find_bulk_errata_ids([@host], params[:bulk_errata_ids])
       end
     end
+
+    def validate_index_params!
+      if (params[:content_view_id] && params[:environment_id].nil?) || (params[:environment_id] && params[:content_view_id].nil?)
+        fail _("Either both parameters 'content_view_id' and 'environment_id' should be specified or neither should be specified")
+      end
+      if params[:type].present?
+        fail _("Type must be one of: %s" % TYPES_FROM_PARAMS.keys.join(', ')) unless TYPES_FROM_PARAMS.key?(params[:type].to_sym)
+      end
+      if params[:severity].present?
+        fail _("Severity must be one of: %s") % Katello::Erratum::SEVERITIES.join(', ') unless Katello::Erratum::SEVERITIES.include?(params[:severity])
+      end
+    end
   end
 end

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

@@ -1,5 +1,6 @@
 module Katello
   class Api::V2::HostTracerController < Api::V2::ApiController
+    include Katello::Concerns::FilteredAutoCompleteSearch
     before_action :find_host
 
     resource_description do
@@ -14,7 +15,7 @@ module Katello
       respond_for_index(:collection => collection)
     end
 
-    api :PUT, "/hosts/:host_id/traces/resolve", N_("Resolve Traces")
+    api :PUT, "/hosts/:host_id/traces/resolve", N_("Resolve traces")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
     def resolve

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

@@ -35,6 +35,10 @@ module Katello
       %w(name asc)
     end
 
+    def all_for_content_view_filter(filter, _collection)
+      ModuleStream.joins(:repositories).merge(filter.applicable_repos)
+    end
+
     def available_for_content_view_filter(filter, _collection)
       collection_ids = []
       current_ids = filter.module_stream_rules.map(&:module_stream_id)

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

@@ -6,7 +6,7 @@ module Katello
     include ForemanTasks::Triggers
 
     before_action :local_find_taxonomy, :only => %w(repo_discover cancel_repo_discover
-                                                    download_debug_certificate
+                                                    download_debug_certificate cdn_configuration
                                                     redhat_provider update releases)
 
     resource_description do
@@ -55,12 +55,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")
+    param :redhat_repository_url, String, :desc => N_("Red Hat CDN URL"), deprecated: true
     param_group :resource
     def update
-      if params.key?(:redhat_repository_url)
-        org_params = params.permit(:redhat_repository_url).to_h
-        sync_task(::Actions::Katello::Provider::Update, @organization.redhat_provider, org_params)
+      if params[:redhat_repository_url]
+        sync_task(::Actions::Katello::CdnConfiguration::Update, @organization.cdn_configuration, url: params[:redhat_repository_url])
       end
       super
     end
@@ -133,7 +132,23 @@ module Katello
       respond_for_index :collection => response
     end
 
-    api :GET, '/organizations/:id/redhat_provider', N_('List all :resource_id')
+    api :PUT, "/organizations/:id/cdn_configuration", N_("Update the CDN configuration")
+    param :id, String, :desc => N_("ID of the Organization"), :required => true
+    param :ssl_ca_credential_id, Integer, :desc => N_("Content Credential to use for SSL CA")
+    param :username, String, :desc => N_("Username for authentication")
+    param :password, String, :desc => N_("Password for authentication")
+    param :upstream_organization_label, String, :desc => N_("Upstream organization to sync CDN content from")
+    param :url, String, :desc => N_("Upstream server to sync CDN content from")
+    def cdn_configuration
+      config_keys = [:url, :username, :password, :upstream_organization_label, :ssl_ca_credential_id]
+      config_params = params.slice(*config_keys).permit!.to_h
+
+      task = sync_task(::Actions::Katello::CdnConfiguration::Update, @organization.cdn_configuration, config_params)
+
+      respond_for_async :resource => task
+    end
+
+    api :GET, '/organizations/:id/redhat_provider', N_('List all :resource_id'), deprecated: true
     def redhat_provider
       respond_for_show(:resource => @organization.redhat_provider,
                        :resource_name => "providers")
@@ -142,7 +157,7 @@ module Katello
     protected
 
     def action_permission
-      if %w(download_debug_certificate redhat_provider repo_discover
+      if %w(download_debug_certificate redhat_provider repo_discover cdn_configuration
             cancel_repo_discover).include?(params[:action])
         :edit
       elsif params[:action] == "releases"

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

@@ -35,7 +35,7 @@ module Katello
       syncable_roots = RootRepository.where(:product_id => syncable_products).has_url
 
       syncable_roots = syncable_roots.yum_type if skip_metadata_check || validate_contents
-      syncable_roots = syncable_roots.where.not(:download_policy => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND) if validate_contents
+      syncable_roots = syncable_roots.where.not(:download_policy => ::Katello::RootRepository::DOWNLOAD_ON_DEMAND) if validate_contents
 
       syncable_repositories = Katello::Repository.where(:root_id => syncable_roots).in_default_view
       fail _("No syncable repositories found for selected products and options.") if syncable_roots.empty?

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

@@ -27,6 +27,7 @@ module Katello
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
     before_action :error_on_rh_product, :only => [:create]
+    before_action :check_import_parameters, :only => [:import_uploads]
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_GPG_KEY_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE }
@@ -57,8 +58,6 @@ module Katello
       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 :ostree_upstream_sync_policy, ::Katello::RootRepository::OSTREE_UPSTREAM_SYNC_POLICIES, :desc => N_("policies for syncing upstream ostree repositories")
-      param :ostree_upstream_sync_depth, :number, :desc => N_("if a custom sync policy is chosen for ostree repositories then a 'depth' value must be provided")
       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")
@@ -98,7 +97,6 @@ module Katello
     param :rpm_id, String, :desc => N_("Id of a rpm package to find repositories that contain the rpm")
     param :file_id, String, :desc => N_("Id of a file to find repositories that contain the file")
     param :ansible_collection_id, String, :desc => N_("Id of an ansible collection to find repositories that contain the ansible collection")
-    param :ostree_branch_id, String, :desc => N_("Id of an ostree branch to find repositories that contain that branch")
     param :library, :bool, :desc => N_("show repositories in Library and the default content view")
     param :archived, :bool, :desc => N_("show archived repositories")
     param :content_type, RepositoryTypeManager.defined_repository_types.keys, :desc => N_("limit to only repositories of this type")
@@ -108,7 +106,7 @@ module Katello
     param :available_for, String, :desc => N_("interpret specified object to return only Repositories that can be associated with specified object.  Only 'content_view' & 'content_view_version' are supported."),
           :required => false
     param :with_content, RepositoryTypeManager.enabled_content_types(false), :desc => N_("only repositories having at least one of the specified content type ex: rpm , erratum")
-    param :download_policy, ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES, :desc => N_("limit to only repositories with this download policy")
+    param :download_policy, ::Katello::RootRepository::DOWNLOAD_POLICIES, :desc => N_("limit to only repositories with this download policy")
     param :username, String, :desc => N_("only show the repositories readable by this user with this username")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Repository)
@@ -214,9 +212,10 @@ module Katello
                     .where("#{AnsibleCollection.table_name}.id" => AnsibleCollection.with_identifiers(params[:ansible_collection_id]))
       end
 
-      if params[:ostree_branch_id]
-        query = query.joins(:ostree_branches)
-          .where("#{OstreeBranch.table_name}.id" => OstreeBranch.with_identifiers(params[:ostree_branch_id]))
+      generic_type_param = RepositoryTypeManager.generic_content_types.find { |type| params["#{type}_id".to_sym] }
+      if generic_type_param
+        query = query.joins(:generic_content_units)
+                     .where("#{GenericContentUnit.table_name}.id" => GenericContentUnit.with_identifiers(params["#{generic_type_param}_id".to_sym]))
       end
 
       query
@@ -265,8 +264,12 @@ module Katello
 
     api :PUT, "/repositories/:id/republish", N_("Forces a republish of the specified repository, regenerating metadata and symlinks on the filesystem.")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
+    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use mirror on sync."), :required => true
     def republish
-      task = async_task(::Actions::Katello::Repository::MetadataGenerate, @repository, :force => true)
+      unless ::Foreman::Cast.to_bool(params[:force])
+        fail HttpErrors::BadRequest, _('Metadata republishing must be forced because it is a dangerous operation.')
+      end
+      task = async_task(::Actions::Katello::Repository::MetadataGenerate, @repository)
       respond_for_async :resource => task
     end
 
@@ -336,8 +339,10 @@ module Katello
 
     api :DELETE, "/repositories/:id", N_("Destroy a custom repository")
     param :id, :number, :required => true
+    param :remove_from_content_view_versions, :bool, :required => false, :desc => N_("Force delete the repository by removing it from all content view versions")
     def destroy
-      sync_task(::Actions::Katello::Repository::Destroy, @repository)
+      sync_task(::Actions::Katello::Repository::Destroy, @repository,
+        remove_from_content_view_versions: ::Foreman::Cast.to_bool(params.fetch(:remove_from_content_view_versions, false)))
       respond_for_destroy
     end
 
@@ -388,7 +393,7 @@ module Katello
     param :async, :bool, desc: N_("Do not wait for the ImportUpload action to finish. Default: false")
     param 'publish_repository', :bool, :desc => N_("Whether or not to regenerate the repository on disk. Default: true")
     param 'sync_capsule', :bool, :desc => N_("Whether or not to sync an external capsule after upload. Default: true")
-    param :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'rpm', 'srpm')")
+    param :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree_ref', 'rpm', 'srpm')")
     param :uploads, Array, :desc => N_("Array of uploads to import") do
       param 'id', String, :required => true
       param 'content_unit_id', String
@@ -397,6 +402,12 @@ module Katello
       param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags")
       param 'digest', String, :desc => N_("Needs to only be set for docker tags")
     end
+    Katello::RepositoryTypeManager.generic_repository_types.each_pair do |_, repo_type|
+      repo_type.import_attributes.each do |import_attribute|
+        param import_attribute.api_param, import_attribute.type,
+            :desc => N_(import_attribute.description)
+      end
+    end
     def import_uploads
       generate_metadata = ::Foreman::Cast.to_bool(params.fetch(:publish_repository, true))
       sync_capsule = ::Foreman::Cast.to_bool(params.fetch(:sync_capsule, true))
@@ -432,6 +443,11 @@ module Katello
       end
     end
 
+    api :GET, "/content_types", N_("Return the enabled content types")
+    def content_types
+      render :json => Katello::RepositoryTypeManager.enabled_content_types.map { |type| Katello::RepositoryTypeManager.find_content_type(type) }
+    end
+
     protected
 
     def find_product
@@ -465,11 +481,9 @@ module Katello
     def repository_params
       keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password,
               :upstream_username, :download_concurrency, :upstream_authentication_token,
-              :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, {:os_versions => []},
-              :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy,
-              :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
+              {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
+              :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
              ]
-
       keys += [{:docker_tags_whitelist => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
       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"
@@ -503,7 +517,6 @@ module Katello
     end
 
     # rubocop:disable Metrics/PerceivedComplexity
-    # 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,
@@ -526,10 +539,6 @@ module Katello
         root.generic_remote_options = generic_remote_options.to_json
       end
 
-      if root.ostree?
-        root.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]
-        root.ostree_upstream_sync_depth = repo_params[:ostree_upstream_sync_depth]
-      end
       if root.deb?
         root.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
         root.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
@@ -607,5 +616,13 @@ module Katello
       end
       generic_remote_options
     end
+
+    def check_import_parameters
+      @repository.repository_type&.import_attributes&.each do |import_attribute|
+        if import_attribute.required && params[import_attribute.api_param].blank?
+          fail HttpErrors::UnprocessableEntity, _("%s is required", import_attributes.api_param)
+        end
+      end
+    end
   end
 end

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

@@ -94,7 +94,6 @@ module Katello
     api :POST, "/organizations/:organization_id/subscriptions/upload", N_("Upload a subscription manifest")
     param :organization_id, :number, :desc => N_("Organization id"), :required => true
     param :content, File, :desc => N_("Subscription manifest file"), :required => true
-    param :repository_url, String, :desc => N_("repository url"), :required => false
     def upload
       fail HttpErrors::BadRequest, _("No manifest file uploaded") if params[:content].blank?
 
@@ -106,12 +105,6 @@ module Katello
         temp_file.close
       end
 
-      # repository url
-      if (repo_url = params[:repository_url])
-        @provider.repository_url = repo_url
-        @provider.save!
-      end
-
       task = async_task(::Actions::Katello::Organization::ManifestImport, @organization, File.expand_path(temp_file.path), params[:force])
       respond_for_async :resource => task
     end
@@ -159,7 +152,6 @@ module Katello
     def find_provider
       @organization = @activation_key.organization if @activation_key
       @organization = @subscription.organization if @subscription
-      @provider = @organization.redhat_provider if @organization
     end
 
     private

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

@@ -27,7 +27,11 @@ module Katello
       page = index_params[:page] || 1
 
       collection = scoped_search_results(
-        pools[:pools], pools[:subtotal], pools[:total], page, index_params[:per_page], nil)
+        query: pools[:pools],
+        subtotal: pools[:subtotal],
+        total: pools[:total],
+        page: page,
+        per_page: index_params[:per_page])
       respond(collection: collection)
     end
 

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

@@ -0,0 +1,40 @@
+module Katello
+  module Concerns
+    module Api::V2::BulkExtensions
+      extend ActiveSupport::Concern
+
+      def find_bulk_items(bulk_params:, model_scope:, key: :id)
+        if bulk_params.is_a?(String)
+          bulk_params = ActiveSupport::JSON.decode(bulk_params).
+                        deep_symbolize_keys
+        end
+
+        bulk_params[:included] ||= {}
+        bulk_params[:excluded] ||= {}
+
+        if (!bulk_params[:all]) &&
+            bulk_params[:included][:ids].blank? &&
+            bulk_params[:included][:search].blank?
+          fail HttpErrors::BadRequest, _("No items have been specified.")
+        end
+
+        if bulk_params[:all] && !bulk_params[:included][:ids].blank?
+          fail HttpErrors::BadRequest, _("Sending a list of included IDs is not allowed when all items are being selected.")
+        end
+
+        items = model_scope
+        if bulk_params[:included][:ids]
+          items = model_scope.where(key => bulk_params[:included][:ids])
+        elsif bulk_params[:included][:search]
+          items = model_scope.search_for(bulk_params[:included][:search])
+        end
+
+        if bulk_params[:excluded][:ids]
+          items = items.where.not(key => bulk_params[:excluded][:ids])
+        end
+
+        items
+      end
+    end
+  end
+end

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

@@ -1,39 +1,12 @@
 module Katello
   module Concerns
     module Api::V2::HostErrataExtensions
-      extend ActiveSupport::Concern
+      include Api::V2::BulkExtensions
 
       def find_bulk_errata_ids(hosts, bulk_errata_ids)
-        bulk_params = ActiveSupport::JSON.decode(bulk_errata_ids).deep_symbolize_keys
-        bulk_params[:included] ||= {}
-        bulk_params[:excluded] ||= {}
-
-        if bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
-          fail HttpErrors::BadRequest, _("No errata has been specified.")
-        end
-
-        #works on a structure of param_group bulk_params and transforms it into a list of errata_ids
-        errata = ::Katello::Erratum.installable_for_hosts(hosts)
-
-        if bulk_params[:included][:ids]
-          errata = errata.where(:errata_id => bulk_params[:included][:ids])
-        end
-
-        if bulk_params[:included][:search]
-          search_errata = ::Katello::Erratum.installable_for_hosts(hosts)
-          search_errata = search_errata.search_for(bulk_params[:included][:search])
-
-          if errata.any?
-            errata = errata.merge(search_errata)
-          else
-            errata = search_errata
-          end
-        end
-
-        if bulk_params[:excluded][:ids].present?
-          errata = errata.where.not(errata_id: bulk_params[:excluded][:ids])
-        end
-
+        errata = find_bulk_items(bulk_params: bulk_errata_ids,
+                                 model_scope: ::Katello::Erratum.installable_for_hosts(hosts),
+                                 key: :errata_id)
         errata.pluck(:errata_id)
       end
     end

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

@@ -35,7 +35,7 @@ module Katello
 
       def smart_proxy
         @smart_proxy ||= begin
-          proxy = params[:url] ? SmartProxy.find_by(url: params[:url]) : SmartProxy.pulp_primary
+          proxy = params[:url] ? SmartProxy.unscoped.find_by(url: params[:url]) : SmartProxy.pulp_primary
 
           fail Foreman::Exception, _('Smart proxy content source not found!') unless proxy
           fail Foreman::Exception, _('Pulp 3 is not enabled on Smart proxy!') unless proxy.pulp3_enabled?

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

@@ -44,7 +44,7 @@ module Katello
         respond :resource => @resource
       end
 
-      api :GET, "/:resource_id/compare/", N_("List :resource_id")
+      api :GET, "/:resource_id/compare/", N_("List :resource")
       param :content_view_version_ids, Array, :desc => N_("content view versions to compare")
       param :repository_id, :number, :desc => N_("Library repository id to restrict comparisons to")
       def compare

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

@@ -29,15 +29,11 @@ module Katello
         policies = [
           {
             :name => _("On Demand"),
-            :label => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
-          },
-          {
-            :name => _("Background"),
-            :label => ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
+            :label => ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
           },
           {
             :name => _("Immediate"),
-            :label => ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE
+            :label => ::Katello::RootRepository::DOWNLOAD_IMMEDIATE
           },
           {
             :name => _("Inherit from Repository"),

data/app/helpers/katello/katello_url_helper.rb

@@ -2,7 +2,7 @@ module Katello
   module KatelloUrlHelper
     unless defined? CONSTANTS_DEFINED
       FILEPREFIX = ['file'].freeze
-      PROTOCOLS = ['http', 'https', 'ftp'].freeze
+      PROTOCOLS = ['http', 'https', 'ftp', 'uln'].freeze
 
       CONSTANTS_DEFINED = true
     end

data/app/lib/actions/candlepin/abstract_async_task.rb

@@ -26,15 +26,18 @@ module Actions
       end
 
       def done?
+        check_for_errors!(external_task)
         !::Katello::Resources::Candlepin::Job.not_finished?(external_task)
       end
 
       private
 
+      def job_poll_params
+        {}
+      end
+
       def poll_external_task
-        task = ::Katello::Resources::Candlepin::Job.get(external_task[:id])
-        check_for_errors!(task)
-        task
+        ::Katello::Resources::Candlepin::Job.get(external_task[:id], job_poll_params)
       end
 
       def check_for_errors!(task)

data/app/lib/actions/candlepin/async_hypervisors.rb

@@ -6,16 +6,20 @@ module Actions
         param :task_id
       end
 
-      def poll_external_task(task_id = external_task[:id])
-        task = ::Katello::Resources::Candlepin::Job.get(task_id, :result_data => true)
-        unless ::Katello::Resources::Candlepin::Job.not_finished?(task)
-          output[:hypervisors] = ::Actions::Katello::Host::Hypervisors.parse_hypervisors(task.delete('resultData'))
-        end
-        task
+      def invoke_external_task
+        self.external_task = { :id => input[:task_id] }
+        poll_external_task
       end
 
-      def invoke_external_task
-        poll_external_task(input[:task_id])
+      def on_finish
+        super
+        output[:hypervisors] = ::Actions::Katello::Host::Hypervisors.parse_hypervisors(external_task.delete('resultData'))
+      end
+
+      private
+
+      def job_poll_params
+        {:result_data => true}
       end
     end
   end

data/app/lib/actions/katello/applicability/hosts/bulk_generate.rb

@@ -26,8 +26,17 @@ module Actions
             :link
           end
 
+          def hostname(host_id)
+            content_facet = ::Katello::Host::ContentFacet.find_by_host_id(host_id)
+            content_facet&.host&.name
+          end
+
           def humanized_name
-            _("Bulk generate applicability for hosts")
+            if input[:host_ids]&.length == 1
+              _("Bulk generate applicability for host %s" % hostname(input[:host_ids].first))
+            else
+              _("Bulk generate applicability for hosts")
+            end
           end
         end
       end

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

@@ -4,7 +4,7 @@ module Actions
       class SyncCapsule < ::Actions::EntryAction
         include Actions::Katello::PulpSelector
         def plan(smart_proxy, options = {})
-          plan_self(:smart_proxy_id => smart_proxy.id, :options => options)
+          plan_self(:smart_proxy_id => smart_proxy.id)
           action_subject(smart_proxy)
           environment = options[:environment]
           content_view = options[:content_view]
@@ -29,7 +29,7 @@ module Actions
                 repo_batch.each do |repo|
                   if repo.is_a?(::Katello::Repository) &&
                       repo.distribution_bootable? &&
-                      repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+                      repo.download_policy == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
                     plan_action(Katello::Repository::FetchPxeFiles,
                                 id: repo.id,
                                 capsule_id: smart_proxy.id)
@@ -64,7 +64,7 @@ module Actions
         end
 
         def run
-          smart_proxy = ::SmartProxy.find(input[:smart_proxy_id])
+          smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
           smart_proxy.sync_container_gateway
         end