katello 4.3.0.rc1 → 4.3.0.rc4

data/app/lib/actions/pulp3/repository/import_upload.rb

@@ -4,10 +4,11 @@ module Actions
   module Pulp3
     module Repository
       class ImportUpload < Pulp3::AbstractAsyncTask
-        def plan(save_artifact_output, repository, smart_proxy)
+        def plan(save_artifact_output, repository, smart_proxy, options = {})
           plan_self(:save_artifact_output => save_artifact_output,
                     :repository_id => repository.id,
-                    :smart_proxy_id => smart_proxy.id)
+                    :smart_proxy_id => smart_proxy.id,
+                    :options => options)
         end
 
         def invoke_external_task
@@ -19,6 +20,7 @@ module Actions
 
           repo = ::Katello::Repository.find(input[:repository_id])
           repo_backend_service = repo.backend_service(smart_proxy)
+
           output[:content_unit_href] = content_unit_href
           output[:pulp_tasks] = [repo_backend_service.add_content(content_unit_href)]
         end

data/app/lib/actions/pulp3/repository/reclaim_space.rb

@@ -0,0 +1,25 @@
+module Actions
+  module Pulp3
+    module Repository
+      class ReclaimSpace < Pulp3::AbstractAsyncTask
+        def plan(repositories, smart_proxy = SmartProxy.pulp_primary)
+          repositories = [repositories] if repositories.is_a?(::Katello::Repository)
+          if repositories.empty?
+            fail _("No repositories selected.")
+          end
+          repositories = repositories.select { |repo| repo.download_policy == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND }
+          if repositories.empty?
+            fail _("Only On Demand repositories may have space reclaimed.")
+          end
+          repository_hrefs = ::Katello::Pulp3::RepositoryReference.default_cv_repository_hrefs(repositories, Organization.current)
+          plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
+        end
+
+        def invoke_external_task
+          output[:pulp_tasks] = ::Katello::Pulp3::Api::Core.new(SmartProxy.find(input[:smart_proxy_id])).
+            repositories_reclaim_space_api.reclaim(repo_hrefs: input[:repository_hrefs])
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/save_artifact.rb

@@ -2,6 +2,7 @@ module Actions
   module Pulp3
     module Repository
       class SaveArtifact < Pulp3::AbstractAsyncTask
+        #This task creates a content unit and may or may not create a new repository version in the process
         def plan(file, repository, smart_proxy, tasks, unit_type_id, options = {})
           options[:file_name] = file[:filename]
           options[:sha256] = file[:sha256] || Digest::SHA256.hexdigest(File.read(file[:path]))
@@ -15,17 +16,20 @@ module Actions
           content_type = input[:unit_type_id]
           content_backend_service = SmartProxy.pulp_primary.content_service(content_type)
 
-          existing_content = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, input['unit_type_id'], {filename: input[:options][:file_name]}, input[:options][:sha256])
+          existing_content = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, input[:unit_type_id], {filename: input[:options][:file_name]}, input[:options][:sha256])
           existing_content_href = existing_content&.results&.first&.pulp_href
 
-          if existing_content_href
-            output[:content_unit_href] = existing_content_href
-            []
+          if ::Katello::RepositoryTypeManager.find_content_type(input[:unit_type_id]).repository_import_on_upload
+            output[:pulp_tasks] = [repository.backend_service(smart_proxy).repository_import_content(artifact_href, input[:options])]
           else
-            output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
-                                                                              artifact: artifact_href,
-                                                                              repository_id: input[:repository_id],
-                                                                              content_type: content_type)]
+            if existing_content_href
+              output[:content_unit_href] = existing_content_href
+              []
+            else
+              output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
+                                                                                artifact: artifact_href,
+                                                                                content_type: content_type)]
+            end
           end
         end
 

data/app/lib/katello/resources/cdn.rb

@@ -41,7 +41,12 @@ module Katello
                                     :ssl_ca_cert)
 
           if options[:ssl_ca_cert].present?
-            ca_cert = OpenSSL::X509::Certificate.new(options[:ssl_ca_cert])
+            begin
+              ca_cert = OpenSSL::X509::Certificate.new(options[:ssl_ca_cert])
+            rescue
+              raise _("Invalid SSL CA certificate given for CDN")
+            end
+
             @cert_store = OpenSSL::X509::Store.new
             @cert_store.add_cert(ca_cert)
           end
@@ -112,6 +117,7 @@ module Katello
           net
         end
 
+        # rubocop:disable Metrics/MethodLength
         def get(path, _headers = {})
           net = http_downloader
           path = File.join(@uri.request_uri, path)
@@ -140,6 +146,8 @@ module Katello
                 fail exception_class.new(nil, code)
               end
             end
+          rescue SocketError
+            raise _("Couldn't establish a connection to %s") % @uri
           rescue EOFError
             raise RestClient::ServerBrokeConnection
           rescue Timeout::Error
@@ -152,6 +160,7 @@ module Katello
             raise Errors::SecurityViolation, _("CDN loading error: access forbidden to %s") % used_url
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def valid_path?(path, postfix)
           get(File.join(path, postfix)).present?

data/app/lib/katello/resources/registry.rb

@@ -32,7 +32,7 @@ module Katello
             self.prefix = "/pulpcore_registry/"
             self.site = "#{uri.scheme}://#{uri.host}:#{uri.port}"
             self.ca_cert_file = Setting[:ssl_ca_file]
-            pulp_primary.pulp3_ssl_configuration(self)
+            pulp_primary.pulp3_ssl_configuration(self, :net_http)
 
             self
           end

data/app/models/katello/concerns/host_managed_extensions.rb

@@ -383,12 +383,15 @@ module Katello
         @traces_status_label ||= get_status(::Katello::TraceStatus).to_label(options)
       end
 
-      def traces_helpers(ids = nil)
-        traces = host_traces
-        traces = host_traces.where(id: ids) if ids.present?
+      def traces_helpers(search:)
+        traces = host_traces.selectable.search_for(search)
         ::Katello::HostTracer.helpers_for(traces)
       end
 
+      def advisory_ids(search:)
+        ::Katello::Erratum.installable_for_hosts([self]).search_for(search).pluck(:errata_id)
+      end
+
       def valid_content_override_label?(content_label)
         available_content = subscription_facet.candlepin_consumer.available_product_content
         available_content.map(&:content).any? { |content| content.label == content_label }
@@ -411,7 +414,7 @@ end
 class ::Host::Managed::Jail < Safemode::Jail
   allow :content_source, :subscription_manager_configuration_url, :rhsm_organization_label,
         :host_collections, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
-        :installed_packages, :traces_helpers
+        :installed_packages, :traces_helpers, :advisory_ids
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail

data/app/models/katello/concerns/smart_proxy_extensions.rb

@@ -185,17 +185,17 @@ module Katello
         end
       end
 
-      def pulp3_ssl_configuration(config)
-        legacy_pulp_cert = !self.setting(PULP3_FEATURE, 'client_authentication')&.include?('client_certificates')
+      def pulp3_ssl_configuration(config, connection_adapter = Faraday.default_adapter)
+        legacy_pulp_cert = !self.setting(PULP3_FEATURE, 'client_authentication')&.include?('client_certificate')
 
-        if Faraday.default_adapter == :excon
+        if connection_adapter == :excon
           config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename(use_admin_as_cn_cert: legacy_pulp_cert)
           config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename(use_admin_as_cn_cert: legacy_pulp_cert)
-        elsif Faraday.default_adapter == :net_http
+        elsif connection_adapter == :net_http
           config.ssl_client_cert = ::Cert::Certs.ssl_client_cert(use_admin_as_cn_cert: legacy_pulp_cert)
           config.ssl_client_key = ::Cert::Certs.ssl_client_key(use_admin_as_cn_cert: legacy_pulp_cert)
         else
-          fail "Unexpected faraday default_adapter #{Faraday.default_adapter}!  Cannot continue, this is likely a bug."
+          fail "Unexpected connection_adapter #{Faraday.default_adapter}!  Cannot continue, this is likely a bug."
         end
       end
 
@@ -423,7 +423,7 @@ module Katello
         repos = Katello::Repository
         repos = repos.in_environment(environment) if environment
         repos = repos.in_content_views([content_view]) if content_view
-        repos
+        repos.respond_to?(:to_a) ? repos : repos.none
       end
 
       def repos_in_sync_history
@@ -444,12 +444,24 @@ module Katello
       end
 
       def rhsm_url
-        if pulp_primary?
-          "https://#{URI.parse(url).host}/rhsm"
+        # Since Foreman 3.1 this setting is set
+        if (rhsm_url = setting(SmartProxy::PULP3_FEATURE, 'rhsm_url'))
+          URI(rhsm_url)
+        # Compatibility fall back
+        elsif pulp_primary?
+          URI("https://#{URI.parse(url).host}/rhsm")
         elsif pulp_mirror?
-          "https://#{URI.parse(url).host}:8443/rhsm"
+          URI("https://#{URI.parse(url).host}:8443/rhsm")
         end
       end
+
+      def pulp_content_url
+        URI(setting(SmartProxy::PULP3_FEATURE, 'content_app_url'))
+      end
+
+      class ::SmartProxy::Jail < ::Safemode::Jail
+        allow :rhsm_url, :pulp_content_url
+      end
     end
   end
 end

data/app/models/katello/content_view_version.rb

@@ -314,10 +314,6 @@ module Katello
       FileUnit.in_repositories(archived_repos)
     end
 
-    def ostree_branches
-      OstreeBranch.in_repositories(archived_repos)
-    end
-
     def docker_manifests
       DockerManifest.in_repositories(archived_repos)
     end
@@ -357,8 +353,7 @@ module Katello
       update_content_counts! if content_counts.blank?
       counts = Hash[content_counts.map { |key, value| ["#{key}_count", value] }]
       counts.merge("module_stream_count" => counts["modulemd_count"],
-                   "package_count" => counts["rpm_count"],
-                   "ostree_branch_count" => counts["ostree_count"])
+                   "package_count" => counts["rpm_count"])
     end
 
     def check_ready_to_promote!(to_env)

data/app/models/katello/glue/pulp/repo.rb

@@ -90,8 +90,7 @@ module Katello
           errata.count != pulp_counts['erratum'].to_i ||
           package_groups.count != pulp_counts['package_group'].to_i ||
           docker_manifests.count != pulp_counts['docker_manifest'].to_i ||
-          docker_tags.count != pulp_counts['docker_tag'].to_i ||
-          ostree_branches.count != pulp_counts['ostree'].to_i
+          docker_tags.count != pulp_counts['docker_tag'].to_i
       end
 
       def empty_in_pulp?

data/app/models/katello/host_tracer.rb

@@ -5,10 +5,12 @@ module Katello
     belongs_to :host, :inverse_of => :host_traces, :class_name => '::Host::Managed'
 
     scope :reboot_required, -> { where(app_type: 'static') }
+    scope :selectable, -> { where.not(app_type: 'session') }
 
     validates :application, :length => {:maximum => 255}, :presence => true
     validates :app_type, :length => {:maximum => 255}, :presence => true
 
+    scoped_search :on => :id, :only_explicit => true
     scoped_search :on => :application, :complete_value => true
     scoped_search :on => :app_type, :complete_value => true
     scoped_search :on => :helper, :complete_value => true

data/app/models/katello/pulp3/repository_reference.rb

@@ -3,6 +3,13 @@ module Katello
     class RepositoryReference < Katello::Model
       belongs_to :root_repository, :class_name => 'Katello::RootRepository'
       belongs_to :content_view, :class_name => 'Katello::ContentView'
+
+      def self.default_cv_repository_hrefs(repositories, organizations)
+        organizations = [organizations] if organizations.is_a?(::Organization)
+        where(content_view_id: organizations.map(&:default_content_view).compact.pluck(:id)).
+            where(root_repository_id: repositories.pluck(:root_id)).
+              select(:repository_href).pluck(:repository_href)
+      end
     end
   end
 end

data/app/models/katello/repository.rb

@@ -79,9 +79,6 @@ module Katello
     has_many :repository_docker_meta_tags, :class_name => "Katello::RepositoryDockerMetaTag", :dependent => :delete_all
     has_many :docker_meta_tags, :through => :repository_docker_meta_tags
 
-    has_many :repository_ostree_branches, :class_name => "Katello::RepositoryOstreeBranch", :dependent => :delete_all
-    has_many :ostree_branches, :through => :repository_ostree_branches
-
     has_many :repository_debs, :class_name => "Katello::RepositoryDeb", :dependent => :delete_all
     has_many :debs, :through => :repository_debs
 
@@ -178,7 +175,7 @@ module Katello
     delegate :name, :created_at, :updated_at, :major, :minor, :gpg_key_id, :gpg_key, :arch, :label, :url, :unprotected,
              :content_type, :product_id, :checksum_type, :docker_upstream_name, :mirror_on_sync, :"mirror_on_sync?",
              :download_policy, :verify_ssl_on_sync, :"verify_ssl_on_sync?", :upstream_username, :upstream_password,
-             :upstream_authentication_token, :ostree_upstream_sync_policy, :ostree_upstream_sync_depth, :deb_releases,
+             :upstream_authentication_token, :deb_releases,
              :deb_components, :deb_architectures, :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id,
              :ssl_client_key_id, :os_versions, :ssl_client_key, :ignorable_content, :description, :docker_tags_whitelist,
              :ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token,
@@ -259,13 +256,7 @@ module Katello
     end
 
     def self.undisplayable_types
-      ret = [::Katello::Repository::CANDLEPIN_DOCKER_TYPE]
-
-      unless ::Katello::RepositoryTypeManager.enabled?(Repository::OSTREE_TYPE)
-        ret << ::Katello::Repository::CANDLEPIN_OSTREE_TYPE
-      end
-
-      ret
+      [::Katello::Repository::CANDLEPIN_DOCKER_TYPE]
     end
 
     def self.in_organization(org)
@@ -693,10 +684,6 @@ module Katello
       end
     end
 
-    def ostree_branch_names
-      self.ostree_branches.map(&:name)
-    end
-
     def units_for_removal(ids, type_class = nil)
       removable_unit_association = unit_type_for_removal(type_class)
       table_name = removable_unit_association.table_name
@@ -739,21 +726,6 @@ module Katello
       }
     end
 
-    def check_duplicate_branch_names(branch_names)
-      dupe_branch_checker = {}
-      dupe_branch_checker.default = 0
-      branch_names.each do |branch|
-        dupe_branch_checker[branch] += 1
-      end
-
-      duplicate_branch_names = dupe_branch_checker.select { |_, value| value > 1 }.keys
-
-      unless duplicate_branch_names.empty?
-        fail ::Katello::Errors::ConflictException,
-              _("Duplicate branches specified - %{branches}") % { branches: duplicate_branch_names.join(", ")}
-      end
-    end
-
     # deleteable? is already taken by the authorization mixin
     def destroyable?(remove_from_content_view_versions = false)
       if self.environment.try(:library?) && self.content_view.default?

data/app/models/katello/root_repository.rb

@@ -18,18 +18,10 @@ module Katello
     IGNORABLE_CONTENT_UNIT_TYPES = %w(srpm).freeze
     CHECKSUM_TYPES = %w(sha1 sha256).freeze
 
-    OSTREE_UPSTREAM_SYNC_POLICY_LATEST = "latest".freeze
-    OSTREE_UPSTREAM_SYNC_POLICY_ALL = "all".freeze
-    OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM = "custom".freeze
-    OSTREE_UPSTREAM_SYNC_POLICIES = [OSTREE_UPSTREAM_SYNC_POLICY_LATEST, OSTREE_UPSTREAM_SYNC_POLICY_ALL, OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM].freeze
-
     SUBSCRIBABLE_TYPES = [Repository::YUM_TYPE, Repository::OSTREE_TYPE, Repository::DEB_TYPE].freeze
 
     CONTENT_ATTRIBUTE_RESTRICTIONS = {
-      :ostree_upstream_sync_depth => [Repository::OSTREE_TYPE],
-      :ostree_upstream_sync_policy => [Repository::OSTREE_TYPE],
       :download_policy => [Repository::YUM_TYPE, Repository::DEB_TYPE]
-
     }.freeze
 
     NO_DEFAULT_HTTP_PROXY = 'none'.freeze
@@ -43,7 +35,8 @@ module Katello
     RHEL6 = 'rhel-6'.freeze
     RHEL7 = 'rhel-7'.freeze
     RHEL8 = 'rhel-8'.freeze
-    ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8].freeze
+    RHEL9 = 'rhel-9'.freeze
+    ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8, RHEL9].freeze
 
     belongs_to :product, :inverse_of => :root_repositories, :class_name => "Katello::Product"
     has_one :provider, :through => :product
@@ -59,8 +52,6 @@ module Katello
     has_many :repository_references, :class_name => 'Katello::Pulp3::RepositoryReference', :foreign_key => :root_repository_id,
              :dependent => :destroy, :inverse_of => :root_repository
 
-    before_validation :update_ostree_upstream_sync_policy
-
     validates_lengths_from_database :except => [:label]
     validates_with Validators::KatelloLabelFormatValidator, :attributes => :label
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
@@ -83,12 +74,8 @@ module Katello
     validate :ensure_valid_authentication_token, :if => :yum?
     validate :ensure_valid_deb_constraints, :if => :deb?
     validate :ensure_no_checksum_on_demand
-    validates :url, presence: true, if: :ostree?
     validates :checksum_type, :inclusion => {:in => CHECKSUM_TYPES}, :allow_blank => true
     validates :product_id, :presence => true
-    validates :ostree_upstream_sync_policy, :inclusion => {:in => OSTREE_UPSTREAM_SYNC_POLICIES, :allow_blank => true}, :if => :ostree?
-    validates :ostree_upstream_sync_depth, :presence => true, :numericality => { :only_integer => true },
-      :if => proc { |r| r.ostree? && r.ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM }
     validates :content_type, :inclusion => {
       :in => ->(_) { Katello::RepositoryTypeManager.enabled_repository_types.keys },
       :allow_blank => false,
@@ -203,34 +190,6 @@ module Katello
       end
     end
 
-    def update_ostree_upstream_sync_policy
-      return unless ostree?
-      if self.ostree_upstream_sync_policy.blank?
-        self.ostree_upstream_sync_policy = OSTREE_UPSTREAM_SYNC_POLICY_LATEST
-      end
-
-      if self.ostree_upstream_sync_policy_changed? &&
-        previous_changes[:ostree_upstream_sync_policy].present?
-        self.ostree_upstream_sync_depth = nil unless self.ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM
-      end
-    end
-
-    def compute_ostree_upstream_sync_depth
-      if ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM
-        ostree_upstream_sync_depth
-      elsif ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_ALL
-        -1
-      else
-        0
-      end
-    end
-
-    def ensure_no_ostree_upstream_sync_policy
-      if !ostree? && ostree_upstream_sync_policy.present?
-        errors.add(:ostree_upstream_sync_policy, N_("cannot be set for non-ostree repositories."))
-      end
-    end
-
     def ensure_valid_ignorable_content
       return if ignorable_content.blank?
       if !yum?
@@ -372,7 +331,7 @@ module Katello
 
     def pulp_update_needed?
       changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync
-                                 upstream_username upstream_password ostree_upstream_sync_policy ostree_upstream_sync_depth ignorable_content
+                                 upstream_username upstream_password ignorable_content
                                  ssl_ca_cert_id ssl_client_cert_id ssl_client_key_id http_proxy_policy http_proxy_id download_concurrency)
       changeable_attributes += %w(name container_repository_name docker_tags_whitelist) if docker?
       changeable_attributes += %w(deb_releases deb_components deb_architectures gpg_key_id) if deb?

data/app/models/setting/content.rb

@@ -13,7 +13,6 @@ class Setting::Content < Setting
     download_policies = proc { hashify_parameters(::Katello::RootRepository::DOWNLOAD_POLICIES) }
 
     proxy_download_policies = proc { hashify_parameters(::SmartProxy::DOWNLOAD_POLICIES) }
-    dependency_solving_options = proc { hashify_parameters(['conservative', 'greedy']) }
     cdn_ssl_versions = proc { hashify_parameters(Katello::Resources::CDN::SUPPORTED_SSL_VERSIONS) }
     http_proxy_select = [{
       name: _("HTTP Proxies"),
@@ -125,12 +124,6 @@ class Setting::Content < Setting
       self.set('content_view_solve_dependencies',
                N_('The default dependency solving value for new Content Views.'),
                false, N_('Content View Dependency Solving Default')),
-      self.set('dependency_solving_algorithm',
-               N_("How the logic of solving dependencies in a Content View is managed. Conservative will only add " \
-               "packages to solve the dependencies if the package needed doesn't exist. Greedy will pull in the " \
-               "latest package to solve a dependency even if it already does exist in the repository."),
-               'conservative', N_('Content View Dependency Solving Algorithm'), nil,
-               :collection => dependency_solving_options),
       self.set('host_dmi_uuid_duplicates',
                N_("If hosts fail to register because of duplicate DMI UUIDs " \
                   "add their comma-separated values here. Subsequent registrations will generate a unique DMI UUID for the affected hosts."),
@@ -154,7 +147,8 @@ class Setting::Content < Setting
       self.set('bulk_load_size', N_('The number of items fetched from a single paged Pulp API call.'), 2000,
                N_('Pulp bulk load size')),
       self.set('upload_profiles_without_dynflow', N_('Allow Katello to update host installed packages, enabled repos, and module inventory directly instead of wrapped in Dynflow tasks (try turning off if Puma processes are using too much memory)'), true,
-               N_('Upload profiles without Dynflow'))
+               N_('Upload profiles without Dynflow')),
+      self.set('orphan_protection_time', N_('Time in minutes to consider orphan content as orphaned.'), 1440, N_('Orphaned Content Protection Time'))
     ]
   end
 

data/app/presenters/katello/host_package_presenter.rb

@@ -0,0 +1,21 @@
+module Katello
+  class HostPackagePresenter < SimpleDelegator
+    attr_accessor :installed_package, :upgradable_version, :rpm_id
+
+    def initialize(installed_package, upgradable_version, rpm_id)
+      @installed_package = installed_package
+      @upgradable_version = upgradable_version
+      @rpm_id = rpm_id
+      super(@installed_package)
+    end
+
+    def self.with_latest(packages, host)
+      upgradable_packages_map = ::Katello::Rpm.installable_for_hosts([host]).select(:id, :name, :nvra, :evr).order(evr: :desc).all.group_by(&:name)
+      installed_packages_map = ::Katello::Rpm.where(nvra: packages.map(&:nvra)).select(:id, :name).group_by(&:name)
+
+      packages.map do |p|
+        HostPackagePresenter.new(p, upgradable_packages_map[p.name]&.first&.nvra, installed_packages_map[p.name]&.first&.id)
+      end
+    end
+  end
+end

data/app/services/katello/bulk_items_helper.rb

@@ -0,0 +1,35 @@
+module Katello
+  class BulkItemsHelper
+    attr_reader :bulk_params, :model_scope, :key
+
+    def initialize(bulk_params:, model_scope:, key: :id)
+      @bulk_params = bulk_params
+
+      if @bulk_params.is_a?(String)
+        @bulk_params = ActiveSupport::JSON.decode(@bulk_params).
+                      deep_symbolize_keys
+      end
+
+      @model_scope = model_scope
+      @key = key
+    end
+
+    def fetch
+      params = bulk_params
+      params[:included] ||= {}
+      params[:excluded] ||= {}
+
+      items = model_scope
+      if params[:included][:ids]
+        items = model_scope.where(key => params[:included][:ids])
+      elsif params[:included][:search]
+        items = model_scope.search_for(params[:included][:search])
+      end
+      if params[:excluded][:ids]
+        items = items.where.not(key => params[:excluded][:ids])
+      end
+
+      items
+    end
+  end
+end

data/app/services/katello/pulp3/api/core.rb

@@ -55,6 +55,10 @@ module Katello
           repository_type.distributions_api_class.new(api_client)
         end
 
+        def core_repositories_api
+          PulpcoreClient::RepositoriesApi.new(core_api_client)
+        end
+
         def repositories_api
           repository_type.repositories_api_class.new(api_client)
         end
@@ -81,6 +85,10 @@ module Katello
           end
         end
 
+        def repositories_reclaim_space_api
+          PulpcoreClient::RepositoriesReclaimSpaceApi.new(core_api_client)
+        end
+
         def exporter_api
           PulpcoreClient::ExportersPulpApi.new(core_api_client)
         end
@@ -102,7 +110,7 @@ module Katello
         end
 
         def orphans_api
-          PulpcoreClient::OrphansApi.new(core_api_client)
+          PulpcoreClient::OrphansCleanupApi.new(core_api_client)
         end
 
         def artifacts_api
@@ -152,7 +160,7 @@ module Katello
         end
 
         def delete_orphans
-          [orphans_api.delete]
+          [orphans_api.cleanup(PulpcoreClient::OrphansCleanup.new(orphan_protection_time: Setting[:orphan_protection_time]))]
         end
 
         def delete_remote(remote_href)
@@ -192,6 +200,12 @@ module Katello
           ignore_404_exception { distributions_api.delete(href) }
         end
 
+        def core_repositories_list_all(options = {})
+          self.class.fetch_from_list do |page_opts|
+            core_repositories_api.list(page_opts.merge(options))
+          end
+        end
+
         def list_all(options = {})
           self.class.fetch_from_list do |page_opts|
             repositories_api.list(page_opts.merge(options))

data/app/services/katello/pulp3/content.rb

@@ -6,10 +6,12 @@ module Katello
       class << self
         def create_upload(size = 0, checksum = nil, content_type = nil, repository = nil)
           content_unit_href = nil
-          if checksum
+          content_type = ::Katello::RepositoryTypeManager.find_content_type(content_type)
+
+          if checksum && !content_type.repository_import_on_upload
             content_backend_service = SmartProxy.pulp_primary.content_service(content_type)
             if repository&.generic?
-              content_list = content_backend_service.content_api(repository.repository_type, content_type).list("sha256": checksum)
+              content_list = content_backend_service.content_api(repository.repository_type, content_type).list('sha256': checksum)
             else
               content_list = content_backend_service.content_api.list("sha256": checksum)
             end

data/app/services/katello/pulp3/pulp_content_unit.rb

@@ -116,24 +116,30 @@ module Katello
         content_unit_list page_opts
       end
 
+      # rubocop:disable Lint/UselessAssignment
       def self.find_duplicate_unit(repository, unit_type_id, file, checksum)
+        filter_label = 'sha256'
+        if unit_type_id == 'ostree_ref'
+          filter_label = 'checksum'
+        end
         content_backend_service = SmartProxy.pulp_primary.content_service(unit_type_id)
         duplicates_allowed = ::Katello::RepositoryTypeManager.find_content_type(unit_type_id).try(:duplicates_allowed)
         if repository.generic? && duplicates_allowed
           filename_key = ::Katello::RepositoryTypeManager.find_content_type(unit_type_id).filename_key
           duplicate_sha_path_content_list = content_backend_service.content_api(repository.repository_type, unit_type_id).list(
-            "sha256": checksum,
+            filter_label: checksum,
             filename_key => file[:filename])
         elsif repository.generic?
           duplicate_sha_path_content_list = content_backend_service.content_api(repository.repository_type, unit_type_id).list(
-            "sha256": checksum)
+            filter_label: checksum)
         else
           duplicate_sha_path_content_list = content_backend_service.content_api.list(
-            "sha256": checksum,
+            filter_label: checksum,
             "relative_path": file[:filename])
         end
         duplicate_sha_path_content_list
       end
+      # rubocop:enable Lint/UselessAssignment
     end
   end
 end