katello 4.15.0 → 4.16.0.rc1

data/app/assets/javascripts/katello/sync_management/sync_management.js

@@ -124,7 +124,7 @@ KT.content = (function () {
       KT.content.select_repo();
     },
     select_none = function () {
-      $("#products_table").find("input[type=checkbox]").removeAttr("checked");
+      $("#products_table").find("input[type=checkbox]").prop("checked", false);
       KT.content.select_repo();
     },
     select_repo = function () {
@@ -185,7 +185,7 @@ KT.content = (function () {
     expand_all = function () {
       var sync_toggle = $("#sync_toggle");
       if ($(sync_toggle).is(":checked")) {
-        $(sync_toggle).removeAttr("checked");
+        $(sync_toggle).prop("checked", false);
         KT.content.showAll();
       }
       $("#products_table")
@@ -387,6 +387,20 @@ $("#sync_product_form")
     if ($("input[name='repoids[]']:checked").length === 0) {
       return false;
     }
+  })
+  .on("ajax:error", function (event, response) {
+    let errorMessage = localize("error");
+    if (response && response.responseJSON && response.responseJSON.error) {
+      errorMessage = response.responseJSON.error;
+    }
+    if (window.tfm && window.tfm.toastNotifications) {
+      window.tfm.toastNotifications.notify({
+        message: errorMessage,
+        type: "danger",
+      });
+    } else {
+      alert(errorMessage);
+    }
   });
 
 $("#sync_toggle").on("change", function () {

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -5,7 +5,7 @@ module Katello
     before_action :confirm_settings
     skip_before_action :authorize
     before_action :optional_authorize, only: [:token, :catalog]
-    before_action :registry_authorize, except: [:token, :v1_search, :catalog]
+    before_action :registry_authorize, except: [:token, :v1_search, :catalog, :static_index]
     before_action :authorize_repository_read, only: [:pull_manifest, :tags_list, :check_blob, :pull_blob]
     before_action :container_push_prop_validation, only: [:start_upload_blob, :upload_blob, :finish_upload_blob, :push_manifest]
     before_action :create_container_repo_if_needed, only: [:start_upload_blob, :upload_blob, :finish_upload_blob, :push_manifest]
@@ -481,14 +481,18 @@ module Katello
       if !require_user_authorization?
         personal_token = OpenStruct.new(token: 'unauthenticated', issued_at: Time.now, expires_at: 3.minutes.from_now)
       else
-        personal_token = PersonalAccessToken.where(user_id: User.current.id, name: 'registry').first
-        if personal_token.nil?
-          personal_token = PersonalAccessToken.new(user: User.current, name: 'registry', expires_at: 6.minutes.from_now)
-          personal_token.generate_token
-          personal_token.save!
-        else
-          personal_token.expires_at = 6.minutes.from_now
-          personal_token.save!
+        PersonalAccessToken.transaction do
+          personal_token = PersonalAccessToken.where(user_id: User.current.id, name: 'registry').first
+          if personal_token.nil?
+            personal_token = PersonalAccessToken.new(user: User.current, name: 'registry', expires_at: 6.minutes.from_now)
+            personal_token.generate_token
+            personal_token.save!
+          else
+            personal_token.expires_at = 6.minutes.from_now
+            personal_token.save!
+          end
+        rescue ActiveRecord::RecordInvalid
+          personal_token = PersonalAccessToken.where(user_id: User.current.id, name: 'registry').reload.first
         end
       end
 
@@ -806,5 +810,25 @@ module Katello
     def item_not_found(item)
       render_podman_error("NAME_UNKNOWN", _("%s was not found!") % item, :not_found)
     end
+
+    def static_index
+      host_ip = request.remote_ip
+      host = ::Host.joins(:primary_interface).where("nics.ip = :host_ip OR nics.ip6 = :host_ip", host_ip: host_ip)&.first
+      flatpak_index = (redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers) })
+      flatpak_index_json = JSON.parse(flatpak_index)
+      # Filter out repositories if it's a registered host
+      if host&.content_view_environments&.any?
+        # host.update(flatpak_index: flatpak_index) Will this help??
+        repos = host.content_view_environments.flat_map do |cve|
+          cve.content_view_version.repositories
+        end
+        available_container_repo_names = repos.map(&:container_repository_name)
+        flatpak_index_json['Results'] = flatpak_index_json['Results'].select do |result|
+          available_container_repo_names.include?(result['Name'])
+        end
+      end
+      # Otherwise just return unfiltered pulp flatpak index
+      render json: flatpak_index_json
+    end
   end
 end

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

@@ -447,7 +447,7 @@ module Katello
     end
 
     def rhsm_params
-      params.slice(:name, :type, :facts, :installedProducts, :autoheal, :releaseVer, :usage, :role, :addOns, :serviceLevel, :uuid, :capabilities, :guestIds, :lastCheckin).to_h
+      params.slice(:name, :type, :facts, :installedProducts, :autoheal, :releaseVer, :usage, :role, :serviceLevel, :uuid, :capabilities, :guestIds, :lastCheckin).to_h
     end
 
     def logger

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

@@ -13,7 +13,7 @@ module Katello
     before_action :verify_simple_content_access_disabled, :only => [:add_subscriptions]
     before_action :validate_release_version, :only => [:create, :update]
 
-    wrap_parameters :include => (ActivationKey.attribute_names + %w(host_collection_ids service_level auto_attach purpose_role purpose_usage purpose_addons content_view_environments))
+    wrap_parameters :include => (ActivationKey.attribute_names + %w(host_collection_ids service_level auto_attach purpose_role purpose_usage content_view_environments))
 
     def_param_group :activation_key do
       param :organization_id, :number, :desc => N_("organization identifier"), :required => true
@@ -25,11 +25,10 @@ module Katello
       param :auto_attach, :bool, :desc => N_("auto attach subscriptions upon registration"), deprecated: true
       param :purpose_usage, String, :desc => N_("Sets the system purpose usage")
       param :purpose_role, String, :desc => N_("Sets the system purpose usage")
-      param :purpose_addons, Array, :desc => N_("Sets the system add-ons")
 
       param :environment, Hash, :desc => N_("Hash containing the Id of the single lifecycle environment to be associated with the activation key."), deprecated: true
-      param :content_view_id, Integer, :desc => N_("Id of the single content view to be associated with the activation key.")
-      param :environment_id, Integer, :desc => N_("Id of the single lifecycle environment to be associated with the activation key.")
+      param :content_view_id, Integer, :desc => N_("Id of the single content view to be associated with the activation key."), :allow_nil => true
+      param :environment_id, Integer, :desc => N_("Id of the single lifecycle environment to be associated with the activation key."), :allow_nil => true
       param :content_view_environments, Array, :desc => N_("Comma-separated list of content view environment labels to be associated with the activation key,"\
                                               " in the format of 'lifecycle_environment_label/content_view_label'."\
                                               " Ignored if content_view_environment_ids is specified, or if content_view_id and lifecycle_environment_id are specified."\
@@ -314,7 +313,7 @@ module Katello
 
     def find_content_view_environments
       @content_view_environments = []
-      if params[:environment_id] || params[:environment]
+      if (params[:environment_id] || params[:environment]) || (params[:content_view_id] || params[:content_view])
         find_cve_for_single
       elsif params_likely_not_from_angularjs? && (params[:content_view_environments] || params[:content_view_environment_ids])
         @content_view_environments = ::Katello::ContentViewEnvironment.fetch_content_view_environments(
@@ -385,7 +384,6 @@ module Katello
                                              :unlimited_hosts,
                                              :purpose_role,
                                              :purpose_usage,
-                                             :purpose_addon_ids,
                                              :content_overrides => [],
                                              :host_collection_ids => [],
                                              :content_view_environments => [],
@@ -396,9 +394,6 @@ module Katello
       key_params = permitted_params.except(:environment_id, :content_view_id,
                       :content_view_environments, :content_view_environment_ids)
 
-      unless params[:purpose_addons].nil?
-        key_params[:purpose_addon_ids] = params[:purpose_addons].map { |addon| ::Katello::PurposeAddon.find_or_create_by(name: addon).id }
-      end
       unlimited = params[:activation_key].try(:[], :unlimited_hosts)
       max_hosts = params[:activation_key].try(:[], :max_hosts)
 

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

@@ -12,9 +12,10 @@ module Katello
     param :repository_id, :number, :required => true, :desc => N_("repository id")
     param :size, :number, :required => true, :desc => N_("Size of file to upload")
     param :checksum, String, :required => false, :desc => N_("Checksum of file to upload")
-    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 :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'file', 'ostree_ref', 'rpm', 'srpm')")
     def create
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Ansible collections.") if @repository.ansible_collection?
+      fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload container content via Hammer/API. Use podman push instead.") if @repository.docker?
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type)&.default_managed_content_type&.label
       RepositoryTypeManager.check_content_matches_repo_type!(@repository, content_type)
       if ::Katello::RepositoryTypeManager.generic_content_type?(content_type)

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

@@ -40,6 +40,7 @@ module Katello
     param :types, Array, :desc => N_("erratum: types (enhancement, bugfix, security)")
     param :date_type, String, :desc => N_("erratum: search using the 'Issued On' or 'Updated On' column of the errata. Values are 'issued'/'updated'")
     param :module_stream_ids, Array, :desc => N_("module stream ids")
+    param :allow_other_types, :bool, :desc => N_("erratum: allow types not matching a valid errata type")
     def create
       rule_clazz = ContentViewFilter.rule_class_for(@filter)
 
@@ -89,6 +90,7 @@ module Katello
     param :start_date, String, :desc => N_("erratum: start date (YYYY-MM-DD)")
     param :end_date, String, :desc => N_("erratum: end date (YYYY-MM-DD)")
     param :types, Array, :desc => N_("erratum: types (enhancement, bugfix, security)")
+    param :allow_other_types, :bool, :desc => N_("erratum: allow types not matching a valid errata type")
     def update
       update_params = rule_params
       update_params[:name] = update_params[:name].first if update_params[:name]
@@ -136,7 +138,7 @@ module Katello
 
       @rule_params ||= params.fetch(:content_view_filter_rule, {}).
             permit(:uuid, :version, :min_version, :max_version, :architecture,
-                    :errata_id, :start_date, :end_date, :date_type,
+                    :errata_id, :start_date, :end_date, :date_type, :allow_other_types,
                     :types => [], :module_stream_ids => [], :errata_ids => [], name: [])
     end
 

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

@@ -288,7 +288,10 @@ module Katello
       if (!@content_view || !@content_view.composite?)
         attrs.push({:repository_ids => []}, :repository_ids)
       end
-      params.require(:content_view).permit(*attrs).to_h
+      result = params.require(:content_view).permit(*attrs).to_h
+      # sanitize repository_ids to be a list of integers
+      result[:repository_ids] = result[:repository_ids].compact.map(&:to_i) if result[:repository_ids].present?
+      result
     end
 
     def find_environment

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

@@ -84,6 +84,10 @@ module Katello
       ID of an environment that is prior to the new environment in the chain. It has to be
       either the ID of Library or the ID of an environment at the end of a chain.
     DESC
+    param :path_id, Integer, :desc => <<-DESC
+      If you are adding an environment to an existing path after Library, pass the ID of the environment that is the current successor of Library in the path.
+      It has to be the id of the old environment following library in this path.
+    DESC
     def create
       create_params = environment_params
       create_params[:label] = labelize_params(create_params)

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

@@ -59,9 +59,20 @@ module Katello
         fail HttpErrors::UnprocessableEntity, msg
       end
 
+      custom_index_relation_handle_type_and_time(collection)
+    end
+
+    def custom_index_relation_handle_type_and_time(collection)
       collection = collection.where("#{date_type} >= ?", params[:start_date]) if params[:start_date]
       collection = collection.where("#{date_type} <= ?", params[:end_date]) if params[:end_date]
-      collection = collection.of_type(params[:types]) if params[:types]
+      if params[:types]
+        include_other = params[:types]&.include?('other')
+        params[:types]&.delete('other')
+        collection = collection.of_type(
+          params[:types],
+          include_other
+        )
+      end
       collection
     end
 

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

@@ -0,0 +1,81 @@
+module Katello
+  class Api::V2::FlatpakRemoteRepositoriesController < Katello::Api::V2::ApiController
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_action :find_remote_repository, :except => [:index, :auto_complete_search]
+    before_action :find_optional_organization, :only => [:index, :auto_complete_search]
+    before_action :find_product, :only => [:mirror]
+
+    resource_description do
+      name 'Flatpak Remote Repositories'
+    end
+
+    def_param_group :flatpak_remote_repositories do
+      param :name, String, :desc => N_("Name of the flatpak remote repository")
+      param :label, String, :desc => N_("Label of the flatpak remote")
+    end
+
+    api :GET, "/organizations/:organization_id/flatpak_remote_repositories", N_("List flatpak remote repositories")
+    api :GET, "/flatpak_remotes/:flatpak_remote_id/flatpak_remote_repositories", N_("List flatpak remote's repositories")
+    param :organization_id, :number, :desc => N_("organization identifier")
+    param :flatpak_remote_id, :number, :desc => N_("ID of flatpak remote to show repositories of"), :required => true
+    param_group :flatpak_remote_repositories
+    param_group :search, Api::V2::ApiController
+    add_scoped_search_description_for(FlatpakRemoteRepository)
+    def index
+      respond(:collection => scoped_search(index_relation, :name, :asc))
+    end
+
+    def index_relation
+      query = FlatpakRemoteRepository.readable
+      query = index_remote_relation(query)
+      query = query.where(name: params[:name]) if params[:name]
+      query = query.where(label: params[:label]) if params[:label]
+      query
+    end
+
+    def index_remote_relation(query)
+      query = query.joins(:flatpak_remote).where("#{FlatpakRemote.table_name}.organization_id" => @organization) if @organization
+      if params[:flatpak_remote_id]
+        query.where(flatpak_remote_id: params[:flatpak_remote_id])
+      else
+        query
+      end
+    end
+
+    api :GET, "/flatpak_remote_repositories/:id", N_("Show a flatpak remote repository")
+    param :id, :number, :desc => N_("Flatpak remote repository numeric identifier"), :required => true
+    param :manifests, :boolean, :desc => N_("Include manifests"), :required => false
+    def show
+      respond :resource => @flatpak_remote_repository
+    end
+
+    api :POST, "/flatpak_remote_repositories/:id/mirror", N_("Mirror a flatpak remote repository")
+    param :id, :number, :desc => N_("Flatpak remote repository numeric identifier"), :required => true
+    param :product_id, :number, :desc => N_("Product ID to mirror the remote repository to"), :required => true
+    def mirror
+      task = async_task(::Actions::Katello::Flatpak::MirrorRemoteRepository, @flatpak_remote_repository, @product)
+      respond_for_async :resource => task
+    end
+
+    def default_sort
+      %w(name asc)
+    end
+
+    def flatpak_remote_repository_params
+      params.require(:flatpak_remote_repository).permit(:name, :label, :flatpak_remote_id)
+    end
+
+    def find_remote_repository
+      @flatpak_remote_repository = FlatpakRemoteRepository.find(params[:id])
+      throw_resource_not_found(name: 'flatpak_remote_repository', id: params[:id]) unless @flatpak_remote_repository
+      @flatpak_remote_repository
+    end
+
+    def find_product
+      @product = Product.editable.find(params[:product_id])
+      throw_resource_not_found(name: 'product', id: params[:product_id]) unless @product
+      @product
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Katello
+  class Api::V2::FlatpakRemotesController < Katello::Api::V2::ApiController
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_action :find_authorized_katello_resource, :except => [:index, :create, :auto_complete_search]
+    before_action :find_optional_organization, :only => [:index, :auto_complete_search]
+
+    resource_description do
+      name 'Flatpak Remotes'
+    end
+
+    def_param_group :flatpak_remote do
+      param :description, String, :desc => N_("Description of the flatpak remote"), :required => false
+      param :username, String, :desc => N_("Username for the flatpak remote"), :required => false
+      param :token, String, :desc => N_("Token/password for the flatpak remote"), :required => false
+    end
+
+    api :GET, "/organizations/:organization_id/flatpak_remotes", N_("List flatpak remotes")
+    api :GET, "/flatpak_remotes", N_("List flatpak remotes")
+    param :organization_id, :number, :desc => N_("organization identifier"), :required => false
+    param :name, String, :desc => N_("Name of the flatpak remote"), :required => false
+    param_group :search, Api::V2::ApiController
+    add_scoped_search_description_for(FlatpakRemote)
+    def index
+      respond(:collection => scoped_search(index_relation, :name, :asc))
+    end
+
+    def index_relation
+      remotes = FlatpakRemote.readable
+      remotes = remotes.where(organization_id: @organization.id) if @organization
+      remotes = remotes.where(name: params[:name]) if params[:name]
+      remotes = remotes.where(label: params[:label]) if params[:label]
+      remotes
+    end
+
+    api :GET, "/flatpak_remotes/:id", N_("Show a flatpak remote")
+    api :GET, "/organizations/:organization_id/flatpak_remotes/:id", N_("Show a flatpak remote")
+    param :id, :number, :desc => N_("Flatpak remote numeric identifier"), :required => true
+    param :organization_id, :number, :desc => N_("organization identifier")
+    def show
+      respond :resource => @flatpak_remote
+    end
+
+    api :POST, "/flatpak_remotes", N_("Create a flatpak remote")
+    param :name, String, :desc => N_("name"), :required => true
+    param :url, String, :desc => N_("Base URL of the flatpak registry index, ex: https://flatpaks.redhat.io/rhel/ , https://registry.fedoraproject.org/."), :required => true
+    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+    param_group :flatpak_remote
+    def create
+      flatpak_remote = FlatpakRemote.new(flatpak_remote_params)
+      flatpak_remote.save!
+      respond_for_create(resource: flatpak_remote)
+    end
+
+    api :PUT, "/flatpak_remotes/:id", N_("Update a flatpak remote")
+    param_group :flatpak_remote
+    param :id, :number, :desc => N_("Flatpak remote numeric identifier"), :required => true
+    param :name, String, :desc => N_("name")
+    param :url, String, :desc => N_("Base URL of the flatpak registry index, ex: https://flatpaks.redhat.io/rhel/ , https://registry.fedoraproject.org/.")
+    def update
+      @flatpak_remote.update!(flatpak_remote_params)
+      respond_for_show(:resource => @flatpak_remote)
+    end
+
+    api :DELETE, "/flatpak_remotes/:id", N_("Delete a flatpak remote")
+    param :id, :number, :desc => N_("Flatpak remote numeric identifier"), :required => true
+    def destroy
+      @flatpak_remote.destroy
+    end
+
+    api :POST, "/flatpak_remotes/:id/scan", N_("Scan a flatpak remote")
+    param :id, :number, :desc => N_("Flatpak remote numeric identifier"), :required => true
+    def scan
+      task = async_task(::Actions::Katello::Flatpak::ScanRemote, @flatpak_remote)
+      respond_for_async :resource => task
+    end
+
+    def default_sort
+      %w(name asc)
+    end
+
+    def flatpak_remote_params
+      params.require(:flatpak_remote).permit(:name, :url, :description, :organization_id, :username, :token)
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Katello
+  class Api::V2::HostBootcImagesController < Api::V2::ApiController
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    resource_description do
+      api_version 'v2'
+      api_base_url "/api"
+    end
+
+    api :GET, "/hosts/bootc_images", N_("List booted bootc container images for hosts")
+    param_group :search, Api::V2::ApiController
+    def bootc_images
+      params[:sort_by] ||= 'bootc_booted_image'
+      params[:sort_order] ||= 'asc'
+      if params[:order]
+        params[:order] = "#{params[:order].split(' ')[0]} #{sanitize_sort_order(params[:order].split(' ')[1])}"
+      else
+        params[:order] = "#{params[:sort_by]} #{sanitize_sort_order(params[:sort_order])}"
+      end
+      per_page = params[:per_page].present? ? params[:per_page].to_i : Setting[:entries_per_page]
+      page = params[:page].present? ? params[:page].to_i : 1
+
+      bootc_image_map = bootc_host_image_map
+      paged_images = bootc_image_map.to_a.paginate(page: page, per_page: per_page)
+      results = paged_images.collect { |image| { bootc_booted_image: image[0], digests: image[1] } }
+      render json: {
+        total: bootc_image_map.size,
+        page: page,
+        per_page: per_page,
+        subtotal: bootc_image_map.size,
+        sort: {
+          by: params[:sort_by],
+          order: params[:sort_order],
+        },
+        results: results,
+      }
+    end
+
+    private
+
+    def sanitize_sort_order(sort_order)
+      if sort_order.present? && ['asc', 'desc'].include?(sort_order.downcase)
+        sort_order.downcase
+      else
+        'asc'
+      end
+    end
+
+    def index_relation
+      query = resource_class.authorized(:view_hosts).distinct
+      query.joins(:content_facet).where.not(bootc_booted_image: nil, bootc_booted_digest: nil)
+      query
+    end
+
+    def resource_class
+      ::Host::Managed
+    end
+
+    def bootc_host_image_map
+      content_facets = ::Katello::Host::ContentFacet.where(host_id: ::Host::Managed.joins(:content_facet).search_for(params[:search]).pluck(:id))
+      aggregate_bootc_data = content_facets.where.not(bootc_booted_image: nil, bootc_booted_digest: nil).
+          select(:bootc_booted_image, :bootc_booted_digest, 'COUNT(hosts.id) as host_count').
+          joins(:host).group(:bootc_booted_image, :bootc_booted_digest).order(params[:order])
+      bootc_image_map = Hash.new { |h, k| h[k] = [] }
+      aggregate_bootc_data.each do |host_image|
+        bootc_image_map[host_image.bootc_booted_image] << { bootc_booted_digest: host_image.bootc_booted_digest, host_count: host_image.host_count.to_i }
+      end
+      bootc_image_map
+    end
+  end
+end

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

@@ -20,7 +20,6 @@ module Katello
       param :autoheal, :bool, :desc => N_("Sets whether the Host will autoheal subscriptions upon checkin")
       param :purpose_usage, String, :desc => N_("Sets the system purpose usage")
       param :purpose_role, String, :desc => N_("Sets the system purpose usage")
-      param :purpose_addons, Array, :desc => N_("Sets the system add-ons")
       param :service_level, String, :desc => N_("Service level to be used for autoheal")
       param :hypervisor_guest_uuids, Array, :desc => N_("List of hypervisor guest uuids")
       param :installed_products_attributes, Array, :desc => N_("List of products installed on the host") do
@@ -91,7 +90,7 @@ module Katello
       host.reload
       ::Katello::Host::SubscriptionFacet.update_facts(host, rhsm_params[:facts]) unless rhsm_params[:facts].blank?
 
-      respond_for_show(:resource => host, :template => '../../../api/v2/hosts/show')
+      respond_for_show(:resource => host, :full_template => 'katello/api/v2/hosts/show')
     end
 
     def params_to_rhsm_params
@@ -99,7 +98,6 @@ module Katello
       rhsm_params[:releaseVer] = params['release_version'] if params['release_version']
       rhsm_params[:usage] = params['purpose_usage'] if params['purpose_usage']
       rhsm_params[:role] = params['purpose_role'] if params['purpose_role']
-      rhsm_params[:addOns] = params['purpose_addons'] if params['purpose_addons']
       rhsm_params[:serviceLevel] = params['service_level'] if params['service_level']
       rhsm_params[:guestIds] = params['hypervisor_guest_uuids'] if params[:hypervisor_guest_uuids]
       rhsm_params[:type] = Katello::Candlepin::Consumer::SYSTEM
@@ -186,7 +184,7 @@ module Katello
         validate_content_overrides_enabled(override_params)
       end
       sync_task(::Actions::Katello::Host::UpdateContentOverrides, @host, content_override_values, false)
-      fetch_product_content
+      fetch_product_content(!params.dig(:content_overrides_search, :search).nil? && Foreman::Cast.to_bool(params.dig(:content_overrides_search, :limit_to_env)))
     end
 
     api :GET, "/hosts/:host_id/subscriptions/available_release_versions", N_("Show releases available for the content host")
@@ -205,8 +203,8 @@ module Katello
 
     private
 
-    def fetch_product_content
-      content_finder = ProductContentFinder.new(:consumable => @host.subscription_facet)
+    def fetch_product_content(limit_to_env = false)
+      content_finder = ProductContentFinder.new(:match_environment => limit_to_env, :consumable => @host.subscription_facet)
       content = content_finder.presenter_with_overrides(@host.subscription_facet.candlepin_consumer.content_overrides)
       respond_with_template_collection("index", 'repository_sets', :collection => full_result_response(content))
     end

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

@@ -188,7 +188,7 @@ module Katello
     param_group :bulk_params
     def traces
       collection = scoped_search(Katello::HostTracer.where(host_id: @hosts.pluck(:id)), 'application', 'desc', resource_class: Katello::HostTracer)
-      respond_for_index(:collection => collection, :template => '../../../api/v2/host_tracer/index')
+      respond_for_index(:collection => collection, :full_template => 'katello/api/v2/host_tracer/index')
     end
 
     api :PUT, "/hosts/bulk/resolve_traces", N_("Resolve traces for one or more hosts")
@@ -205,14 +205,12 @@ module Katello
     param :service_level, String, :desc => N_("Service level of host")
     param :purpose_role, String, :desc => N_("Role of host")
     param :purpose_usage, String, :desc => N_("Usage of host")
-    param :purpose_addons, Array, :desc => N_("Sets the system add-ons")
     def system_purpose
       task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::UpdateSystemPurpose,
         @hosts,
         params[:service_level],
         params[:purpose_role],
-        params[:purpose_usage],
-        params[:purpose_addons])
+        params[:purpose_usage])
 
       respond_for_async :resource => task
     end
@@ -255,7 +253,7 @@ module Katello
       options[:resource_class] = Katello::ModuleStream
       host_module_streams = Katello::ModuleStream.available_for_hosts(@hosts)
       respond_for_index(collection: scoped_search(host_module_streams, :name, :asc, options),
-                        template: '../../../api/v2/module_streams/name_streams')
+                        full_template: 'katello/api/v2/module_streams/name_streams')
     end
 
     api :PUT, "/hosts/bulk/change_content_source", N_("Update the content source for specified hosts and generate the reconfiguration script")

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

@@ -52,7 +52,7 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
       param :include_tags, Array, :desc => N_("Comma-separated list of tags to sync for a container image repository")
       param :exclude_tags, Array, :desc => N_("Comma-separated list of tags to exclude when syncing a container image repository. Default: any tag ending in \"-source\"")
-      param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum, deb, and docker repos (either 'immediate' or 'on_demand')")
+      param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for deb, docker, file and yum repos (either 'immediate' or 'on_demand')")
       param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
       param :mirroring_policy, Katello::RootRepository::MIRRORING_POLICIES, :desc => N_("Policy to set for mirroring content.  Must be one of %s.") % RootRepository::MIRRORING_POLICIES
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
@@ -307,6 +307,10 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
       repo_params[:ssl_client_cert] = ssl_client_cert
       repo_params[:ssl_client_key] = ssl_client_key
 
+      if repo_params[:package_types]
+        repo_params[:package_types] = repo_params[:package_types].map(& :strip)
+      end
+
       root = construct_repo_from_params(repo_params)
       sync_task(::Actions::Katello::Repository::CreateRoot, root)
       @repository = root.reload.library_instance
@@ -395,6 +399,10 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
         fail "Do not include the username/password in the URL. Use the username/password settings instead."
       end
 
+      if repo_params[:package_types]
+        repo_params[:package_types] = repo_params[:package_types].map(& :strip)
+      end
+
       if @repository.generic?
         generic_remote_options = generic_remote_options_hash(repo_params)
         repo_params[:generic_remote_options] = generic_remote_options.to_json
@@ -403,6 +411,13 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
         end
       end
 
+      additive_policy = ::Katello::RootRepository::MIRRORING_POLICY_ADDITIVE
+      is_repo_param_additive = repo_params[:mirroring_policy] == additive_policy
+      is_root_additive = @repository.root.mirroring_policy == additive_policy
+
+      if @repository.yum? && !(is_repo_param_additive || is_root_additive)
+        repo_params[:retain_package_versions_count] = nil
+      end
       sync_task(::Actions::Katello::Repository::Update, @repository.root, repo_params)
       respond_for_show(:resource => @repository)
     end
@@ -580,7 +595,7 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
       keys = [:download_policy, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
               :upstream_username, :download_concurrency, :metadata_expire,
               {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
-              :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
+              :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}, :sync_dependencies
              ]
       keys += [{:include_tags => []}, {:exclude_tags => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
       keys += [:upstream_authentication_token] if params[:action] == 'create' || @repository&.yum?
@@ -620,7 +635,7 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
       root = @product.add_repo(repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                             :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
                                                             :checksum_type, :download_policy, :http_proxy_policy,
-                                                            :metadata_expire).to_h.with_indifferent_access)
+                                                            :metadata_expire, :sync_dependencies).to_h.with_indifferent_access)
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
       root.mirroring_policy = repo_params[:mirroring_policy] || Katello::RootRepository::MIRRORING_POLICY_CONTENT
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)

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

@@ -18,7 +18,6 @@ module Katello
 
       included do
         prepend Overrides
-        before_action :purpose_addon_params, only: [:create, :update]
         before_action :set_content_view_environments, only: [:create, :update]
 
         def destroy
@@ -35,13 +34,6 @@ module Katello
           render(:locals => { :resource => @host }, :template => 'katello/api/v2/hosts/show', :status => :ok)
         end
 
-        def purpose_addon_params
-          addons = params.dig(:host, :subscription_facet_attributes, :purpose_addons)
-          return if addons.nil?
-          params[:host][:subscription_facet_attributes][:purpose_addon_ids] = addons.map { |addon_name| ::Katello::PurposeAddon.find_or_create_by(name: addon_name).id }
-          params[:host][:subscription_facet_attributes].delete(:purpose_addons)
-        end
-
         def set_content_view_environments
           content_facet_attributes = params.dig(:host, :content_facet_attributes)
           return if content_facet_attributes.blank? || @host&.content_facet.blank? ||