katello 4.3.0.rc1 → 4.3.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf975eaf437422cc7622770087b3b996c0834bb4d0077de55ed4748670c888d2
-  data.tar.gz: a6fbabac90eeed02b2b4a404e1c2d8af1cb245c083daf5981e2471ca035157b5
+  metadata.gz: f0f8ba091ba332e76f76b544ef424c77aa3a38b6b787e8f8f8b36ab1440e25af
+  data.tar.gz: 6f756d679f8b06257ed6b378832b657af76498831e8e22b28a46ae700e228e1e
 SHA512:
-  metadata.gz: d349265901e8142d15ad6ee35fcf6045bec5cbc8197799b9f8b8fac3edbdb29433a40f774345118a86a598587b5656e04aa9f20263cdb81ed388c9f373414a55
-  data.tar.gz: ee28f705628e3ff302918e2bf30ba5a78addc92454937fe43fc34ed2f48b4388f1f1294c630899884afb0d6071bc9ec733843b52175c1af5ef90160759d0f814
+  metadata.gz: 559529864f4cdb5816256466bcf41b19eaaea681003163b55740760ff264475d20e3a786da8e57faae43580550ead9e6850b72935addca224c20d85264e2ef9d
+  data.tar.gz: a699a711de49a1212a50e24cb7661e310723581a501bb74633ef4f41c062546362631588269452e9d54e39f2a809dc1c5d2a10fa4067f2ba1265fa5e3909a372

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

@@ -134,6 +134,10 @@ module Katello
       scoped_search_results(query: blank_query, page: page, per_page: per_page, error: message)
     end
 
+    def skip_session
+      request.session_options[:skip] = true
+    end
+
     protected
 
     def scoped_search_query(query, group)

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

@@ -63,6 +63,7 @@ module Katello
     param :errata_ids, Array, :desc => N_("List of Errata ids to install. Will be removed in %s") % katello_agent_removal_release, required: true
 
     param_group :bulk_errata_ids
+    param_group :search, Api::V2::ApiController
     def apply
       task = async_task(::Actions::Katello::Host::Erratum::Install, @host, content: @errata_ids)
       respond_for_async :resource => task
@@ -143,7 +144,11 @@ module Katello
         missing = params[:errata_ids] - Erratum.where(:errata_id => params[:errata_ids]).pluck(:errata_id)
         fail HttpErrors::NotFound, _("Couldn't find errata ids '%s'") % missing.to_sentence if missing.any?
         @errata_ids = params[:errata_ids]
+      elsif params[:search]
+        @errata_ids = @host.advisory_ids(search: params[:search])
       else
+        # old angular way
+        # Todo: remove this when the old content-host errata page is removed
         @errata_ids = find_bulk_errata_ids([@host], params[:bulk_errata_ids])
       end
     end

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

@@ -20,10 +20,12 @@ module Katello
 
     api :GET, "/hosts/:host_id/packages", N_("List packages installed on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
+    param :include_latest_upgradable, :boolean, :desc => N_("Also include the latest upgradable package version for each host package")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::InstalledPackage)
     def index
       collection = scoped_search(index_relation, :name, :asc, :resource_class => ::Katello::InstalledPackage)
+      collection[:results] = HostPackagePresenter.with_latest(collection[:results], @host) if ::Foreman::Cast.to_bool(params[:include_latest_upgradable])
       respond_for_index(:collection => collection)
     end
 

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

@@ -35,6 +35,10 @@ module Katello
       @host.host_traces
     end
 
+    def total_selectable(query)
+      query.where(:id => @host.host_traces.selectable).count
+    end
+
     private
 
     def find_host

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

@@ -28,8 +28,8 @@ module Katello
     param :with_custom, :bool, :required => false, :desc => N_("If true, return custom repository sets along with redhat repos")
     param :activation_key_id, :number, :desc => N_("activation key identifier"), :required => false
     param :host_id, :number, :desc => N_("Id of the host"), :required => false
-    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions. Relevant for Activation Keys only")
-    param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the activation key's content view version. Relevant for Activation Keys only")
+    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions.")
+    param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the host's or activation key's content view version and lifecycle environment.")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::ProductContent)
     def index

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

@@ -1,35 +1,28 @@
 module Katello
   class Api::V2::RootController < Api::V2::ApiController
     skip_before_action :authorize # ok - only shows URLs available
+    skip_before_action :load_settings # no Settings used here, avoid DB calls
+    after_action :skip_session
 
     resource_description do
       api_version 'v2'
       api_base_url "/katello/api"
     end
 
-    def resource_list
-      all_routes = Engine.routes.routes
-      all_routes = all_routes.collect { |r| r.path.spec.to_s }
-
-      api_root_routes = all_routes.select do |path|
-        path =~ %r{^/katello/api(\(/:api_version\))?/[^/]+/:id\(\.:format\)$}
-      end
-      api_root_routes = api_root_routes.collect do |path|
-        path = path.sub("(/:api_version)", "")
-        path[0..-(":id(.:format)".length + 1)]
-      end
-
-      api_root_routes.collect! { |r| { :rel => r["/katello/api/".size..-2], :href => r } }
-
-      respond_for_index :collection => api_root_routes
-    end
-
     def rhsm_resource_list
       # The RHSM resource list is required to interact with RHSM on the client.
       # When requested, it will return a list of the resources (href & rel) defined by katello
       # for the /rhsm namespace.  The rel values are used by RHSM to determine if the server
       # supports a particular resource (e.g. environments, guestids, organizations..etc)
 
+      render json: self.class.rhsm_resource_list
+    end
+
+    def self.rhsm_resource_list
+      @rhsm_resource_list ||= generate_rhsm_resource_list
+    end
+
+    def self.generate_rhsm_resource_list
       all_routes = Engine.routes.routes.collect { |r| r.path.spec.to_s }
 
       api_routes = all_routes.select do |path|
@@ -53,8 +46,6 @@ module Katello
 
       api_routes.uniq!
       api_routes.collect! { |r| { :rel => r.split('/').last, :href => r } }
-
-      respond_for_index :collection => api_routes, :template => 'resource_list'
     end
   end
 end

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

@@ -8,7 +8,6 @@ module Katello
           bulk_params = ActiveSupport::JSON.decode(bulk_params).
                         deep_symbolize_keys
         end
-
         bulk_params[:included] ||= {}
         bulk_params[:excluded] ||= {}
 
@@ -22,18 +21,9 @@ module Katello
           fail HttpErrors::BadRequest, _("Sending a list of included IDs is not allowed when all items are being selected.")
         end
 
-        items = model_scope
-        if bulk_params[:included][:ids]
-          items = model_scope.where(key => bulk_params[:included][:ids])
-        elsif bulk_params[:included][:search]
-          items = model_scope.search_for(bulk_params[:included][:search])
-        end
-
-        if bulk_params[:excluded][:ids]
-          items = items.where.not(key => bulk_params[:excluded][:ids])
-        end
-
-        items
+        ::Katello::BulkItemsHelper.new(bulk_params: bulk_params,
+                                       model_scope: model_scope,
+                                       key: key).fetch
       end
     end
   end

data/app/controllers/katello/remote_execution_controller.rb

@@ -48,7 +48,7 @@ module Katello
 
       def inputs
         if feature_name == 'katello_errata_install'
-          { :errata => errata_inputs }
+          { "Errata Search Query" => "errata_id ^ (#{errata_inputs.join(',')})" }
         elsif feature_name == 'katello_service_restart'
           { :helper => params[:name] }
         elsif feature_name == 'katello_module_stream_action'

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

@@ -3,6 +3,7 @@ module Actions
     module CapsuleContent
       class SyncCapsule < ::Actions::EntryAction
         include Actions::Katello::PulpSelector
+        # rubocop:disable Metrics/MethodLength
         def plan(smart_proxy, options = {})
           plan_self(:smart_proxy_id => smart_proxy.id)
           action_subject(smart_proxy)
@@ -17,11 +18,11 @@ module Actions
             repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
                 repo_batch.each do |repo|
-                  plan_pulp_action(
-                    [Actions::Pulp::Orchestration::Repository::SmartProxySync,
-                     Actions::Pulp3::CapsuleContent::Sync],
-                                     repo, smart_proxy,
-                                     skip_metadata_check: skip_metadata_check)
+                  if smart_proxy.backend_service_type(repo) == Actions::Pulp3::Abstract::BACKEND_SERVICE_TYPE
+                    plan_action(Actions::Pulp3::CapsuleContent::Sync,
+                      repo, smart_proxy,
+                      skip_metadata_check: skip_metadata_check)
+                  end
                 end
               end
 
@@ -39,6 +40,7 @@ module Actions
             end
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def repos_to_sync(smart_proxy, environment, content_view, repository, skip_metatadata_check = false)
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)

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

@@ -37,7 +37,7 @@ module Actions
               handle_redhat_content(repository) unless skip_environment_update
             else
               if destroy_content && !skip_environment_update
-                handle_custom_content(repository)
+                handle_custom_content(repository, remove_from_content_view_versions)
               end
             end
           end
@@ -57,9 +57,9 @@ module Actions
           end
         end
 
-        def handle_custom_content(repository)
+        def handle_custom_content(repository, remove_from_content_view_versions)
           #if this is the last instance of a custom repo, destroy the content
-          if repository.root.repositories.where.not(id: repository.id).empty?
+          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty?
             plan_action(::Actions::Katello::Product::ContentDestroy, repository.root)
           end
         end

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

@@ -77,8 +77,6 @@ module Actions
             Presenters::FileUnitPresenter.new(self)
           elsif repo.try(:docker?)
             Presenters::DockerPresenter.new(self)
-          elsif repo.try(:ostree?)
-            Presenters::OstreePresenter.new(self)
           elsif repo.try(:deb?)
             Presenters::DebPresenter.new(self)
           end

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

@@ -46,7 +46,7 @@ module Actions
       end
 
       def combined_tasks
-        return nil if pulp_tasks.nil? || task_groups.nil?
+        return nil if pulp_tasks.nil? && task_groups.nil?
         pulp_tasks + task_groups
       end
 
@@ -120,11 +120,23 @@ module Actions
       end
 
       def external_task=(external_task_data)
-        #currently we assume everything coming from invoke_external_task_methods are tasks
         tasks = transform_task_response(external_task_data)
-        output[:pulp_tasks] = new_or_existing_objects(::Katello::Pulp3::Task, tasks)
+        output[:pulp_tasks] = [] if output[:pulp_tasks].nil?
+        output[:task_groups] = [] if output[:task_groups].nil?
+        if tasks.detect { |task| task['task'] || (task['pulp_href'] && !task['tasks']) }
+          output[:pulp_tasks] = new_or_existing_objects(::Katello::Pulp3::Task, tasks)
+          add_task_groups
+        else
+          output[:pulp_tasks] = []
+          tasks.each do |task|
+            if task['task_group']
+              output[:task_groups] << ::Katello::Pulp3::TaskGroup.new_from_href(smart_proxy, task['task_group'])
+            elsif task['pulp_href'] && task['tasks']
+              output[:task_groups] << ::Katello::Pulp3::TaskGroup.new_from_href(smart_proxy, task['pulp_href'])
+            end
+          end
+        end
 
-        add_task_groups
         check_for_errors
       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/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

@@ -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,7 +444,11 @@ module Katello
       end
 
       def rhsm_url
-        if pulp_primary?
+        # Since Foreman 3.1 this setting is set
+        if (rhsm_url = setting(SmartProxy::PULP3_FEATURE, 'rhsm_url'))
+          rhsm_url
+        # Compatibility fall back
+        elsif pulp_primary?
           "https://#{URI.parse(url).host}/rhsm"
         elsif pulp_mirror?
           "https://#{URI.parse(url).host}:8443/rhsm"

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/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
@@ -86,9 +77,6 @@ module Katello
     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 +191,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 +332,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/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/smart_proxy_helper.rb

@@ -39,11 +39,20 @@ module Katello
       end
     end
 
-    def repositories_available_to_capsule(environments, content_view)
+    def repositories_available_to_capsule(environments = nil, content_view = nil)
       environments = @smart_proxy.lifecycle_environments if environments.nil?
       yum_repos = Katello::Repository.in_environment(environments)
       yum_repos = yum_repos.in_content_views([content_view]) if content_view
       yum_repos.smart_proxy_syncable
     end
+
+    def unsyncable_content_types
+      unsyncable_content_types = ::Katello::RepositoryTypeManager.defined_repository_types.keys.collect do |type_name|
+        unless @smart_proxy.capabilities(::SmartProxy::PULP3_FEATURE).include?(::Katello::RepositoryTypeManager.defined_repository_types[type_name].pulp3_plugin)
+          type_name
+        end
+      end
+      unsyncable_content_types.compact & repositories_available_to_capsule.map(&:content_type)
+    end
   end
 end