katello 4.18.0 → 4.19.0.rc1

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

@@ -7,6 +7,7 @@ module Katello
     skip_before_action :authorize
     before_action :optional_authorize, only: [:token, :catalog]
     before_action :registry_authorize, except: [:token, :v1_search, :catalog, :static_index]
+    before_action :static_index_authorize, only: [: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]
@@ -63,7 +64,7 @@ module Katello
                                              "scope=\"repository:registry:pull,push\""
     end
 
-    def set_user_by_token(token, redirect_on_failure = true)
+    def authenticate_from_request(token, redirect_on_failure = true)
       if token
         token_type, token = token.split
         if token_type == 'Bearer' && token
@@ -94,7 +95,7 @@ module Katello
       if @repository && (@repository.environment.registry_unauthenticated_pull || ssl_client_authorized?(@repository.organization.label))
         true
       elsif params['action'] == 'catalog'
-        set_user_by_token(request.headers['Authorization'], false)
+        authenticate_from_request(request.headers['Authorization'], false)
       elsif (params['action'] == 'token' && params['scope'].blank? && params['account'].blank?)
         true
       else
@@ -106,13 +107,26 @@ module Katello
       @repository = find_readable_repository
       return true if ['GET', 'HEAD'].include?(request.method) && @repository && !require_user_authorization?
 
-      is_user_set = set_user_by_token(request.headers['Authorization'])
+      return true if authenticate_from_request(request.headers['Authorization'])
 
-      return true if is_user_set
+      unauthorized
+    end
 
+    def static_index_authorize
+      authenticate_from_request(request.headers['Authorization'])
+      find_host_by_ip unless @host
+      true
+    end
+
+    def find_host_by_ip
+      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
+    end
+
+    def unauthorized
       redirect_authorization_headers
       render_error('unauthorized', :status => :unauthorized)
-      return false
+      false
     end
 
     def container_push_prop_validation(props = nil)
@@ -416,7 +430,12 @@ module Katello
         )
       end
 
-      instance_repo.update!(version_href: latest_version_href)
+      # Fetch version PRN from Pulp API
+      # FIXME: Remove this workaround when https://github.com/pulp/pulpcore/issues/7008 is resolved
+      version_response = pulp_api.repository_versions_api.read(latest_version_href, {fields: 'prn'})
+      latest_version_prn = version_response&.prn
+
+      instance_repo.update!(version_href: latest_version_href, version_prn: latest_version_prn)
       # The Pulp repository should not change after first creation
       if root_repository.repository_references.empty?
         ::Katello::Pulp3::RepositoryReference.where(root_repository_id: instance_repo.root_id,
@@ -432,6 +451,7 @@ module Katello
       instance_repo = root_repository&.library_instance
       distribution_api_response = pulp_api.container_push_distribution_for_repository(pulp_repo_href)
       pulp_distribution_href = distribution_api_response&.pulp_href
+      pulp_distribution_prn = distribution_api_response&.prn
 
       if pulp_distribution_href.empty?
         return render_podman_error(
@@ -445,11 +465,12 @@ module Katello
                                                            repository_id: instance_repo.id).first
       if dist
         if dist.href != pulp_distribution_href
-          dist.update(href: pulp_distribution_href)
+          dist.update(href: pulp_distribution_href, prn: pulp_distribution_prn)
         end
       else
         ::Katello::Pulp3::DistributionReference.create!(path: @container_path_input,
                                                        href: pulp_distribution_href,
+                                                       prn: pulp_distribution_prn,
                                                        repository_id: instance_repo.id)
       end
     end
@@ -574,7 +595,11 @@ module Katello
       return yield
     rescue RestClient::Exception => exception
       if [301, 302, 307].include?(exception.response.code)
-        redirect_to exception.response.headers[:location]
+        # Handle aliased hostname on original request
+        redirect_location = URI(exception.response.headers[:location])
+        redirect_location.host = request.host if request.host.present?
+
+        redirect_to redirect_location.to_s, allow_other_host: true
         nil
       else
         raise exception
@@ -847,12 +872,20 @@ module Katello
     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)
       repos = Repository.readable_docker_catalog(@host)
-      available_container_repo_names = repos.map(&:container_repository_name)
+      return render json: { 'Registry' => request_url, 'Results' => [] } if repos.empty?
+
+      available_container_repo_names = repos.map(&:container_repository_name).compact
+
+      flatpak_index = (redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers) })
+
+      begin
+        flatpak_index_json = JSON.parse(flatpak_index)
+      rescue JSON::ParserError => e
+        Rails.logger.error("Failed to parse flatpak index JSON: #{e.message}")
+        return render json: { 'Registry' => request_url, 'Results' => [] }
+      end
+
       flatpak_index_json['Results'] = flatpak_index_json['Results'].select do |result|
         available_container_repo_names.include?(result['Name'])
       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, :serviceLevel, :uuid, :capabilities, :guestIds, :lastCheckin).to_h
+      params.slice(:name, :type, :facts, :installedProducts, :releaseVer, :usage, :role, :serviceLevel, :uuid, :capabilities, :guestIds, :lastCheckin).to_h
     end
 
     def logger

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

@@ -7,13 +7,11 @@ module Katello
     before_action :find_optional_organization, :only => [:index, :create, :show]
     before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy, :available_releases,
                                                                :available_host_collections, :add_host_collections, :remove_host_collections,
-                                                               :content_override, :add_subscriptions, :remove_subscriptions,
-                                                               :subscriptions]
+                                                               :content_override, :subscriptions]
     before_action :find_content_view_environments, :only => [:create, :update]
-    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 content_view_environments))
+    wrap_parameters :include => (ActivationKey.attribute_names + %w(host_collection_ids service_level purpose_role purpose_usage content_view_environments))
 
     def_param_group :activation_key do
       param :organization_id, :number, :desc => N_("organization identifier"), :required => true
@@ -22,7 +20,6 @@ module Katello
       param :unlimited_hosts, :bool, :desc => N_("can the activation key have unlimited hosts")
       param :release_version, String, :desc => N_("content release version")
       param :service_level, String, :desc => N_("service level")
-      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")
 
@@ -125,8 +122,7 @@ module Katello
       @new_activation_key.reload
       sync_task(::Actions::Katello::ActivationKey::Update, @new_activation_key,
                   :service_level   => @activation_key.service_level,
-                  :release_version => @activation_key.release_version,
-                  :auto_attach     => @activation_key.auto_attach
+                  :release_version => @activation_key.release_version
                )
       @activation_key.pools.each do |pool|
         @new_activation_key.subscribe(pool[:id])
@@ -181,46 +177,6 @@ module Katello
       respond_for_show(:resource => @activation_key)
     end
 
-    def deprecate_entitlement_mode_endpoint
-      ::Foreman::Deprecation.api_deprecation_warning(N_("This endpoint is deprecated and will be removed in an upcoming release. Simple Content Access is the only supported content access mode."))
-    end
-
-    api :PUT, "/activation_keys/:id/add_subscriptions", N_("Attach a subscription"), deprecated: true
-    param :id, :number, :desc => N_("ID of the activation key"), :required => true
-    param :subscription_id, :number, :desc => N_("Subscription identifier"), :required => false
-    param :quantity, :number, :desc => N_("Quantity of this subscription to add"), :required => false
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => false do
-      param :id, String, :desc => N_("Subscription Pool uuid"), :required => false
-      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => false
-    end
-    def add_subscriptions
-      deprecate_entitlement_mode_endpoint
-      if params[:subscriptions]
-        params[:subscriptions].each { |subscription| @activation_key.subscribe(subscription[:id], subscription[:quantity]) }
-      elsif params[:subscription_id]
-        @activation_key.subscribe(params[:subscription_id], params[:quantity])
-      end
-
-      respond_for_index(:collection => subscription_index, :template => 'subscriptions')
-    end
-
-    api :PUT, "/activation_keys/:id/remove_subscriptions", N_("Unattach a subscription"), deprecated: true
-    param :id, :number, :desc => N_("ID of the activation key"), :required => true
-    param :subscription_id, String, :desc => N_("Subscription ID"), :required => false
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => false do
-      param :id, String, :desc => N_("Subscription Pool uuid"), :required => false
-    end
-    def remove_subscriptions
-      deprecate_entitlement_mode_endpoint
-      if params[:subscriptions]
-        params[:subscriptions].each { |subscription| @activation_key.unsubscribe(subscription[:id]) }
-      elsif params[:subscription_id]
-        @activation_key.unsubscribe(params[:subscription_id])
-      end
-
-      respond_for_index(:collection => subscription_index, :template => 'subscriptions')
-    end
-
     api :PUT, "/activation_keys/:id/content_override", N_("Override content for activation_key")
     param :id, :number, :desc => N_("ID of the activation key"), :required => true
     param :content_overrides, Array, :desc => N_("Array of Content override parameters to be added in bulk") do
@@ -273,17 +229,6 @@ module Katello
 
     private
 
-    def subscription_index
-      subs = @activation_key.subscriptions
-      {
-        :results => subs,
-        :subtotal => subs.count,
-        :total => subs.count,
-        :page => 1,
-        :per_page => subs.count,
-      }
-    end
-
     def find_cve_for_single
       environment_id = params.dig(:environment, :id) || params[:environment_id]
       content_view_id = params.dig(:content_view, :id) || params[:content_view_id]
@@ -379,7 +324,6 @@ module Katello
                                              :content_view_id,
                                              :release_version,
                                              :service_level,
-                                             :auto_attach,
                                              :max_hosts,
                                              :unlimited_hosts,
                                              :purpose_role,
@@ -408,12 +352,6 @@ module Katello
       key_params
     end
 
-    def verify_simple_content_access_disabled
-      if @activation_key.organization.simple_content_access?
-        fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
-      end
-    end
-
     def validate_release_version
       @organization ||= find_organization
       if params[:release_version].present? && !@organization.library.available_releases.include?(params[:release_version])

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

@@ -43,52 +43,74 @@ module Katello
 
     private
 
-    def find_export_view_helper(name_importable, name_syncable, organization, generated_for_importable, generated_for_syncable)
+    def find_library_export_view
       if params[:from_history_id].present?
         find_incremental_history_from_id
         @view = @history&.content_view_version&.content_view
       else
-        importable_result = nil
-        syncable_result = nil
-        unless params[:format].present? && params[:format] == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
-          importable_result = determine_view_from_name(name_importable,
-          organization,
-          generated_for_importable)
+        # Determine format for finding existing view
+        format = params[:format] || ::Katello::Pulp3::ContentViewVersion::Export::UNDEFINED
+
+        # Try to find existing views based on format
+        views = []
+        if format != ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+          importable_view = ::Katello::Pulp3::ContentViewVersion::Export.find_export_view(
+            destination_server: params[:destination_server],
+            organization: @organization,
+            name: ::Katello::ContentView::EXPORT_LIBRARY,
+            generated_for: :library_export
+          )
+          views << importable_view if importable_view
         end
-        unless params[:format].present? && params[:format] == ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
-          syncable_result = determine_view_from_name(name_syncable,
-          organization,
-          generated_for_syncable)
+
+        if format != ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
+          syncable_view = ::Katello::Pulp3::ContentViewVersion::Export.find_export_view(
+            destination_server: params[:destination_server],
+            organization: @organization,
+            name: "#{::Katello::ContentView::EXPORT_LIBRARY}-SYNCABLE",
+            generated_for: :library_export_syncable
+          )
+          views << syncable_view if syncable_view
         end
-        @view = [importable_result, syncable_result].compact.max_by(&:updated_at)
+
+        @view = views.compact.max_by(&:updated_at)
       end
       check_for_blank_view
     end
 
-    def find_library_export_view
-      find_export_view_helper(
-        ::Katello::ContentView::EXPORT_LIBRARY,
-        "#{::Katello::ContentView::EXPORT_LIBRARY}-SYNCABLE",
-        @organization,
-        :library_export,
-        :library_export_syncable
-      )
-    end
-
     def find_repository_export_view
-      find_export_view_helper(
-        "Export-#{@repository.label}-#{@repository.library_instance_or_self.id}",
-        "Export-SYNCABLE-#{@repository.label}-#{@repository.library_instance_or_self.id}",
-        @repository.organization,
-        :repository_export,
-        :repository_export_syncable
-      )
-    end
+      if params[:from_history_id].present?
+        find_incremental_history_from_id
+        @view = @history&.content_view_version&.content_view
+      else
+        # Determine format for finding existing view
+        format = params[:format] || ::Katello::Pulp3::ContentViewVersion::Export::UNDEFINED
+
+        # Try to find existing views based on format
+        views = []
+        if format != ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+          importable_view = ::Katello::Pulp3::ContentViewVersion::Export.find_export_view(
+            destination_server: nil,
+            organization: @repository.organization,
+            name: "Export-#{@repository.label}-#{@repository.library_instance_or_self.id}",
+            generated_for: :repository_export
+          )
+          views << importable_view if importable_view
+        end
 
-    def determine_view_from_name(name, organization, generated_for)
-      ::Katello::ContentView.where(name: name,
-                                   organization: organization,
-                                   generated_for: generated_for).first
+        if format != ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
+          syncable_view = ::Katello::Pulp3::ContentViewVersion::Export.find_export_view(
+            destination_server: nil,
+            organization: @repository.organization,
+            name: "Export-SYNCABLE-#{@repository.label}-#{@repository.library_instance_or_self.id}",
+            generated_for: :repository_export_syncable
+          )
+          views << syncable_view if syncable_view
+        end
+
+        @view = views.compact.max_by(&:updated_at)
+      end
+      check_for_blank_view
     end
 
     def check_for_blank_view

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

@@ -95,7 +95,7 @@ module Katello
       update_params = rule_params
       update_params[:name] = update_params[:name].first if update_params[:name]
 
-      if @rule.filter.content_type == ContentViewPackageFilter::CONTENT_TYPE
+      if [ContentViewPackageFilter::CONTENT_TYPE, ContentViewDebFilter::CONTENT_TYPE].include?(@rule.filter.content_type)
         update_params[:version] = "" unless rule_params[:version]
         update_params[:min_version] = "" unless rule_params[:min_version]
         update_params[:max_version] = "" unless rule_params[:max_version]

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

@@ -21,6 +21,7 @@ module Katello
       param :description, String, :desc => N_("Description for the content view")
       param :repository_ids, Array, :desc => N_("List of repository ids")
       param :component_ids, Array, :desc => N_("List of component content view version ids for composite views")
+      param :environment_ids, Array, :desc => N_("List of lifecycle environments for rolling content views")
       param :auto_publish, :bool, :desc => N_("Enable/Disable auto publish of composite view")
       param :solve_dependencies, :bool, :desc => N_("Solve RPM dependencies by default on Content View publish, defaults to false")
       param :import_only, :bool, :desc => N_("Designate this Content View for importing from upstream servers only. Defaults to false")
@@ -42,6 +43,7 @@ module Katello
       {
         :component_ids => Katello::ContentViewVersion,
         :repository_ids => Katello::Repository,
+        :environment_ids => Katello::KTEnvironment,
       }
     end
 
@@ -87,11 +89,12 @@ module Katello
     param :rolling, :bool, :desc => N_("Rolling content view")
     param_group :content_view
     def create
+      validate_environment_ids!(params[:rolling])
       @content_view = ContentView.create!(view_params) do |view|
         view.organization = @organization
         view.label ||= labelize_params(params[:content_view])
       end
-      sync_task(::Actions::Katello::ContentView::Create, @content_view)
+      sync_task(::Actions::Katello::ContentView::Create, @content_view, sanitized_environment_ids)
 
       respond :resource => @content_view
     end
@@ -101,7 +104,8 @@ module Katello
     param :name, String, :desc => N_("New name for the content view")
     param_group :content_view
     def update
-      sync_task(::Actions::Katello::ContentView::Update, @content_view, view_params)
+      validate_environment_ids!(@content_view.rolling?)
+      sync_task(::Actions::Katello::ContentView::Update, @content_view, view_params, sanitized_environment_ids)
       respond :resource => @content_view.reload
     end
 
@@ -299,12 +303,23 @@ module Katello
       if (!@content_view || !@content_view.composite?)
         attrs.push({:repository_ids => []}, :repository_ids)
       end
-      result = params.require(:content_view).permit(*attrs).to_h
+      result = {}
+      result = params.require(:content_view).permit(*attrs).to_h unless action_name == "update" && @content_view.rolling? && params[:content_view].empty?
       # 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 sanitized_environment_ids
+      params[:environment_ids]&.compact&.map(&:to_i)
+    end
+
+    def validate_environment_ids!(rolling)
+      if params[:environment_ids] && !rolling
+        fail HttpErrors::BadRequest, _("It's not possible to provide environment_ids for anything other than a rolling content view.")
+      end
+    end
+
     def find_environment
       return if !params.key?(:environment_id) && params[:action] == "index"
       @environment = KTEnvironment.readable.find(params[:environment_id])

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

@@ -13,15 +13,15 @@ module Katello
     def auto_complete(search)
       page_size = Katello::Concerns::FilteredAutoCompleteSearch::PAGE_SIZE
       debs = Deb.in_repositories(@repositories)
-      col = ''
-      case search
-      when 'name'
-        col = "#{Deb.table_name}.name"
-      when 'arch'
-        col = "#{Deb.table_name}.architecture"
-      end
-      debs = debs.where("#{col} ILIKE ?", "#{params[:term]}%").select(col).group(col).order(col).limit(page_size)
-      render :json => debs.pluck(col)
+      col = case search
+            when 'name' then "#{Deb.table_name}.name"
+            when 'arch' then "#{Deb.table_name}.architecture"
+            end
+      return render json: [] if col.blank?
+
+      scope = debs.select(col).group(col).order(col).limit(page_size)
+      scope = scope.where("#{col} ILIKE ?", "%#{params[:term]}%") if params[:term].present?
+      render json: scope.pluck(Arel.sql(col))
     end
 
     def auto_complete_name
@@ -29,7 +29,7 @@ module Katello
     end
 
     def auto_complete_arch
-      auto_complete('architecture')
+      auto_complete('arch')
     end
 
     api :GET, "/debs", N_("List deb packages")
@@ -52,6 +52,16 @@ module Katello
       super
     end
 
+    def thindex
+      sort_by, sort_order, options = sort_options
+
+      options[:select] = "DISTINCT ON (#{Deb.table_name}.name) #{Deb.table_name}.id, #{Deb.table_name}.name"
+      final_relation = custom_index_relation(Deb.all)
+
+      result = scoped_search(final_relation, sort_by, sort_order, options)
+      respond_for_index(:collection => result, :template => "thindex")
+    end
+
     def final_custom_index_relation(collection)
       # :packages_restrict_latest is intended to filter the result set after all
       # other constraints have been applied, including the scoped_search
@@ -95,7 +105,7 @@ module Katello
         collection = collection.installable_for_hosts(@hosts)
       elsif not_installed && params[:host_id]
         host = @hosts.first
-        collection = Katello::Deb.apt_installable_for_host(host)
+        collection = Katello::Deb.deb_installable_for_host(host)
       elsif applicable
         collection = collection.applicable_to_hosts(@hosts)
       end

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

@@ -46,6 +46,13 @@ module Katello
 
     private
 
+    def custom_index_relation(collection)
+      collection.includes(
+        schema1: { docker_taggable: :docker_manifests },
+        schema2: { docker_taggable: :docker_manifests }
+      )
+    end
+
     def find_repositories
       @repositories = Repository.readable.where(:id => params[:repoids])
     end

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

@@ -55,8 +55,8 @@ module Katello
           collection = collection.applicable_to_hosts(hosts)
         end
       end
-      date_type = params[:date_type].present? ? params[:date_type] : ContentViewErratumFilterRule::UPDATED
-      unless ContentViewErratumFilterRule::DATE_TYPES.include?(date_type)
+      @date_type = params[:date_type].present? ? params[:date_type] : ContentViewErratumFilterRule::UPDATED
+      unless ContentViewErratumFilterRule::DATE_TYPES.include?(@date_type)
         msg = _("Invalid params provided - date_type must be one of %s" % ContentViewErratumFilterRule::DATE_TYPES.join(","))
         fail HttpErrors::UnprocessableEntity, msg
       end
@@ -65,8 +65,8 @@ module Katello
     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.where("#{@date_type} >= ?", params[:start_date]) if params[:start_date]
+      collection = collection.where("#{@date_type} <= ?", params[:end_date]) if params[:end_date]
       if params[:types]
         include_other = params[:types]&.include?('other')
         params[:types]&.delete('other')

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

@@ -4,7 +4,7 @@ module Katello
 
     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]
+    before_action :find_and_validate_product_for_mirroring, :only => [:mirror]
 
     resource_description do
       name 'Flatpak Remote Repositories'
@@ -56,7 +56,6 @@ module Katello
     param :product_name, String, :desc => N_("Name of the product to mirror the remote repository to")
     param :organization_id, :number, :desc => N_("organization identifier")
     def mirror
-      validate_product_for_mirroring
       task = async_task(::Actions::Katello::Flatpak::MirrorRemoteRepository, @flatpak_remote_repository, @product)
       respond_for_async :resource => task
     end
@@ -75,10 +74,17 @@ module Katello
       @flatpak_remote_repository
     end
 
-    def find_product
+    protected
+
+    def rejected_autocomplete_items
+      ['flatpak_remote_id', 'flatpak_remote']
+    end
+
+    private
+
+    def find_and_validate_product_for_mirroring
       if params[:product_id]
-        @product = Product.editable.find(params[:product_id])
-        throw_resource_not_found(name: 'product', id: params[:product_id]) unless @product
+        @product = Product.editable.find(params[:product_id]) # will throw not found if id is invalid
       elsif params[:product_name] && params[:organization_id]
         @product = Product.editable.find_by(name: params[:product_name], organization_id: params[:organization_id])
         unless @product
@@ -86,22 +92,18 @@ module Katello
                   { name: params[:product_name], org_id: params[:organization_id] }
           fail HttpErrors::NotFound, msg
         end
+      elsif params[:product_name]
+        msg = _("Organization must be specified when providing product by name.")
+        fail HttpErrors::BadRequest, msg
+      else
+        msg = _("Product must be specified.")
+        fail HttpErrors::BadRequest, msg
       end
-      @product
-    end
 
-    protected
-
-    def rejected_autocomplete_items
-      ['flatpak_remote_id', 'flatpak_remote']
-    end
-
-    private
-
-    def validate_product_for_mirroring
-      return unless @product&.redhat?
-      msg = _("Flatpak repositories cannot be mirrored into Red Hat products. Please select a custom product.")
-      fail HttpErrors::UnprocessableEntity, msg
+      if @product.redhat?
+        msg = _("Flatpak repositories cannot be mirrored into Red Hat products. Please select a custom product.")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
     end
   end
 end

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

@@ -1,14 +1,29 @@
 module Katello
   class Api::V2::HostDebsController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
+    include Katello::Concerns::Api::V2::RepositoryContentController
 
-    before_action :find_host
+    before_action :find_host, only: [:index]
 
     resource_description do
       api_version 'v2'
       api_base_url "/api"
     end
 
+    api :GET, "/host_debs/installed_debs", N_("Return a list of installed debs distinct by name")
+    param_group :search, ::Katello::Api::V2::ApiController
+    def installed_debs
+      _sort_by, _sort_order, options = sort_options
+      sort_by = 'name'
+      sort_order = 'asc'
+
+      options[:select] = "DISTINCT ON (#{::Katello::InstalledDeb.table_name}.name) #{::Katello::InstalledDeb.table_name}.id, #{::Katello::InstalledDeb.table_name}.name"
+      final_relation = ::Katello::InstalledDeb.all
+
+      result = scoped_search(final_relation, sort_by, sort_order, options)
+      respond_for_index(:collection => result, :template => "installed_debs")
+    end
+
     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")