katello 4.15.1 → 4.16.0.rc1

data/app/models/katello/content_view_erratum_filter.rb

@@ -92,9 +92,21 @@ module Katello
     end
 
     def types_clause
+      # Create an array to store output clauses for quick type filtering later
+      conditions = []
+
+      # Add clauses for types in the filter
       types = erratum_rules.first.types
-      return if types.blank?
-      errata_types_in(types)
+      conditions << errata_types_in(types) unless types.blank?
+
+      # Add clauses for 'other' types
+      conditions << errata_types_not_in(Erratum::TYPES) if erratum_rules.first.allow_other_types?
+
+      # Reduce the array of clauses to a single clause and return
+      return if conditions.empty?
+      conditions.reduce(nil) do |combined_clause, condition|
+        combined_clause ? combined_clause.or(condition) : condition
+      end
     end
 
     def filter_by_id?
@@ -105,6 +117,10 @@ module Katello
       erratum_arel[:errata_type].in(types)
     end
 
+    def errata_types_not_in(types)
+      erratum_arel[:errata_type].not_in(types)
+    end
+
     def errata_in(ids)
       erratum_arel[:errata_id].in(ids)
     end

data/app/models/katello/content_view_version.rb

@@ -108,6 +108,12 @@ module Katello
       name
     end
 
+    def sorted_organization_readable_environments
+      organization_readable_environments = organization.readable_promotion_paths.flatten
+      organization_readable_environments.insert(0, organization.library)
+      organization_readable_environments.intersection(environments)
+    end
+
     def self.contains_file(file_unit_id)
       where(id: Katello::Repository.where(id: Katello::RepositoryFileUnit.where(file_unit_id: file_unit_id).select(:repository_id)).select(:content_view_version_id))
     end

data/app/models/katello/docker_manifest.rb

@@ -5,13 +5,21 @@ module Katello
     has_many :docker_manifest_list_manifests, :class_name => "Katello::DockerManifestListManifest",
              :dependent => :delete_all, :inverse_of => :docker_manifest
     has_many :docker_manifest_lists, :through => :docker_manifest_list_manifests, :inverse_of => :docker_manifests
+    has_many :content_facets, :class_name => "::Katello::Host::ContentFacet", :as => :manifest_entity, :dependent => :nullify
+    has_many :hosts, :class_name => "::Host::Managed", :through => :content_facets, :inverse_of => :docker_manifest
 
     CONTENT_TYPE = "docker_manifest".freeze
 
+    scope :bootable, -> { where(:is_bootable => true) }
+    scope :flatpak, -> { where(:is_flatpak => true) }
+
     scoped_search :relation => :docker_tags, :on => :name, :rename => :tag, :complete_value => true
     scoped_search :on => :digest, :rename => :digest, :complete_value => true, :only_explicit => true
     scoped_search :on => :schema_version, :rename => :schema_version, :complete_value => true, :only_explicit => true
     scoped_search :relation => :docker_manifest_lists, :on => :digest, :rename => :manifest_list_digest, :complete_value => true, :only_explicit => true
+    scoped_search :on => :is_bootable, :rename => :bootable, :complete_value => true, :only_explicit => true
+    scoped_search :on => :is_flatpak, :rename => :flatpak, :complete_value => true, :only_explicit => true
+    scoped_search :on => :content_type, :complete_value => true, :only_explicit => true
 
     def self.default_sort
       order(:schema_version)

data/app/models/katello/docker_manifest_list.rb

@@ -6,12 +6,20 @@ module Katello
     has_many :docker_manifest_list_manifests, :class_name => "Katello::DockerManifestListManifest",
              :dependent => :delete_all, :inverse_of => :docker_manifest_list
     has_many :docker_manifests, :through => :docker_manifest_list_manifests, :inverse_of => :docker_manifest_lists
+    has_many :content_facets, :class_name => "::Katello::Host::ContentFacet", :as => :manifest_entity, :dependent => :nullify
+    has_many :hosts, :class_name => "::Host::Managed", :through => :content_facets, :inverse_of => :docker_manifest_list
 
     CONTENT_TYPE = "docker_manifest_list".freeze
 
+    scope :bootable, -> { where(:is_bootable => true) }
+    scope :flatpak, -> { where(:is_flatpak => true) }
+
     scoped_search :relation => :docker_tags, :on => :name, :rename => :tag, :complete_value => true
     scoped_search :on => :digest, :rename => :digest, :complete_value => true, :only_explicit => true
     scoped_search :on => :schema_version, :rename => :schema_version, :complete_value => true, :only_explicit => true
+    scoped_search :on => :is_bootable, :rename => :bootable, :complete_value => true, :only_explicit => true
+    scoped_search :on => :is_flatpak, :rename => :flatpak, :complete_value => true, :only_explicit => true
+    scoped_search :on => :content_type, :complete_value => true, :only_explicit => true
 
     def self.default_sort
       order(:schema_version)

data/app/models/katello/erratum.rb

@@ -48,8 +48,14 @@ module Katello
                   :validator => ->(value) { ['true', 'false'].include?(value.downcase) },
                   :operators => ["="]
 
-    def self.of_type(type)
-      where(:errata_type => type)
+    def self.of_type(type, include_other = false)
+      if include_other
+        where.not(
+          :errata_type => [Erratum::SECURITY, Erratum::BUGZILLA, Erratum::ENHANCEMENT].flatten
+          ).or(where(:errata_type => type))
+      else
+        where(:errata_type => type)
+      end
     end
 
     scope :security, -> { of_type(Erratum::SECURITY) }

data/app/models/katello/flatpak_remote.rb

@@ -1,5 +1,8 @@
 module Katello
   class FlatpakRemote < Katello::Model
+    include Authorization::FlatpakRemote
+    include ForemanTasks::Concerns::ActionSubject
+
     has_many :remote_repositories, dependent: :destroy, class_name: 'Katello::FlatpakRemoteRepository'
     has_many :remote_repository_manifests, through: :remote_repositories, source: :remote_repository_manifests
     belongs_to :organization, inverse_of: :flatpak_remotes
@@ -7,5 +10,18 @@ module Katello
     validates :name, presence: true
     validates :url, presence: true
     validates :organization_id, presence: true
+    validates :name, :uniqueness => {:scope => :organization_id}
+
+    scope :seeded, -> { where(:seeded => true) }
+
+    scoped_search :on => :name, :complete_value => true
+    scoped_search :on => :organization_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :url, :complete_value => true
+    scoped_search :on => :seeded, :complete_value => true
+    scoped_search :on => :registry_url, :complete_value => true
+
+    def self.humanize_class_name(_name = nil)
+      _("Flatpak Remotes")
+    end
   end
 end

data/app/models/katello/flatpak_remote_repository.rb

@@ -1,5 +1,7 @@
 module Katello
   class FlatpakRemoteRepository < Katello::Model
+    include Ext::LabelFromName
+
     belongs_to :flatpak_remote, inverse_of: :remote_repositories
     has_many :remote_repository_manifests, dependent: :destroy, class_name: 'Katello::FlatpakRemoteRepositoryManifest'
 
@@ -7,6 +9,22 @@ module Katello
     validates :name, presence: true
     validates :label, presence: true
 
+    scoped_search :on => :name, :complete_value => true
+    scoped_search :on => :label, :complete_value => true
+    scoped_search :on => :flatpak_remote_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+
     alias_attribute :manifests, :remote_repository_manifests
+
+    def self.readable
+      where(flatpak_remote_id: FlatpakRemote.readable)
+    end
+
+    def manifest_dependencies
+      FlatpakRemoteRepositoryManifest.where(flatpak_ref: self.manifests&.select(:runtime))
+    end
+
+    def repository_dependencies
+      manifest_dependencies&.map(&:remote_repository)
+    end
   end
 end

data/app/models/katello/flatpak_remote_repository_manifest.rb

@@ -6,5 +6,9 @@ module Katello
                inverse_of: :remote_repository_manifests
     validates :flatpak_remote_repository_id, presence: true
     validates :name, presence: true
+
+    def runtime_dependency
+      FlatpakRemoteRepositoryManifest.where(flatpak_ref: self.runtime)
+    end
   end
 end

data/app/models/katello/glue/candlepin/pool.rb

@@ -10,7 +10,7 @@ module Katello
         lazy_accessor :subscription_facts, :initializer => lambda { |_s| self.subscription ? self.subscription.attributes : {} }
 
         lazy_accessor :pool_derived, :owner, :source_pool_id, :virt_limit, :arch, :description, :product_family,
-          :variant, :suggested_quantity, :support_type, :product_id, :type, :upstream_entitlement_id, :roles, :usage, :addons,
+          :variant, :suggested_quantity, :support_type, :product_id, :type, :upstream_entitlement_id, :roles, :usage,
           :initializer => :pool_facts
 
         lazy_accessor :name, :support_level, :org, :sockets, :cores, :instance_multiplier,

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

@@ -50,7 +50,18 @@ module Katello
       end
 
       def last_sync_audit
-        Audited::Audit.where(:auditable_id => self.repositories, :auditable_type => Katello::Repository.name, :action => "sync").order(:created_at).last
+        repository_ids = self.repositories.pluck(:id)
+        return nil if repository_ids.blank?
+
+        Audited::Audit
+         .where(
+          auditable_id: repository_ids,
+          auditable_type: Katello::Repository.name,
+          action: "sync"
+         )
+         .order(created_at: :desc)
+         .limit(1)
+         .first
       end
 
       def last_sync

data/app/models/katello/host/content_facet.rb

@@ -15,9 +15,20 @@ module Katello
       ALL_TRACER_PACKAGE_NAMES = [ "python-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
                                    "python3-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
                                    HOST_TOOLS_TRACER_PACKAGE_NAME ].freeze
+      BOOTC_FIELD_FACT_NAMES = [
+        "bootc.booted.image",
+        "bootc.booted.digest",
+        "bootc.staged.image",
+        "bootc.staged.digest",
+        "bootc.rollback.image",
+        "bootc.rollback.digest",
+        "bootc.available.image",
+        "bootc.available.digest",
+      ].freeze
 
       belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :inverse_of => :kickstart_content_facets
       belongs_to :content_source, :class_name => "::SmartProxy", :inverse_of => :content_facets
+      belongs_to :manifest_entity, :polymorphic => true, :optional => true, :inverse_of => :content_facets
 
       has_many :content_view_environment_content_facets, :class_name => "Katello::ContentViewEnvironmentContentFacet", :dependent => :destroy, :inverse_of => :content_facet
       has_many :content_view_environments, :through => :content_view_environment_content_facets,
@@ -48,7 +59,7 @@ module Katello
       validates_associated :content_view_environment_content_facets, :message => _("invalid: The content source must sync the lifecycle environment assigned to the host. See the logs for more information.")
       validates :host, :presence => true, :allow_blank => false
       validates :bootc_booted_digest, :bootc_available_digest, :bootc_staged_digest, :bootc_rollback_digest,
-                format: { with: /\Asha256:[A-Fa-f0-9]{64}\z/, message: "must be a valid sha256 digest", allow_nil: true }
+                format: { with: /\Asha256:[A-Fa-f0-9]{64}\z/, message: "must be a valid sha256 digest", allow_blank: true }
 
       scope :with_environments, ->(lifecycle_environments) do
         joins(:content_view_environment_content_facets => :content_view_environment).
@@ -125,7 +136,7 @@ module Katello
       def content_view_environments=(new_cves)
         if new_cves.length > 1 && !Setting['allow_multiple_content_views']
           fail ::Katello::Errors::MultiEnvironmentNotSupportedError,
-          _("Assigning a host to multiple content view environments is not enabled.")
+          _("Assigning a host to multiple content view environments is not enabled. To enable, set the allow_multiple_content_views setting.")
         end
         super(new_cves)
         Katello::ContentViewEnvironmentContentFacet.reprioritize_for_content_facet(self, new_cves)
@@ -308,6 +319,34 @@ module Katello
         Katello::Host::ContentFacet.where(id: non_installable_errata)
       end
 
+      def self.populate_fields_from_facts(host, parser, _type, _source_proxy)
+        return if host.content_facet.blank?
+        facet = host.content_facet || host.build_content_facet
+        attrs_to_add = {}
+        BOOTC_FIELD_FACT_NAMES.each do |fact_name|
+          fact_value = parser.facts[fact_name]
+          field_name = fact_name.tr(".", "_")
+          attrs_to_add[field_name] = fact_value # overwrite with nil if fact is not present
+        end
+        if attrs_to_add['bootc_booted_digest'].present?
+          manifest_entity = find_manifest_entity(digest: attrs_to_add['bootc_booted_digest'])
+          if manifest_entity.present?
+            attrs_to_add['manifest_entity_type'] = manifest_entity.model_name.name
+            attrs_to_add['manifest_entity_id'] = manifest_entity.id
+          else
+            # remove the association if the manifest entity is not found
+            attrs_to_add['manifest_entity_type'] = nil
+            attrs_to_add['manifest_entity_id'] = nil
+          end
+        end
+        facet.assign_attributes(attrs_to_add)
+        facet.save unless facet.new_record?
+      end
+
+      def self.find_manifest_entity(digest:)
+        ::Katello::DockerManifestList.find_by(digest: digest) || ::Katello::DockerManifest.find_by(digest: digest)
+      end
+
       def self.with_applicable_errata(errata)
         self.joins(:applicable_errata).where("#{Katello::Erratum.table_name}.id" => errata)
       end
@@ -414,7 +453,7 @@ module Katello
               :errata_counts, :id, :kickstart_repository, :kickstart_repository_id, :kickstart_repository_name,
               :upgradable_deb_count, :upgradable_module_stream_count, :upgradable_rpm_count, :uuid,
               :installable_security_errata_count, :installable_bugfix_errata_count, :installable_enhancement_errata_count,
-              :single_content_view, :single_lifecycle_environment
+              :single_content_view, :single_lifecycle_environment, :content_view_environment_labels
       end
     end
   end

data/app/models/katello/host/subscription_facet.rb

@@ -12,9 +12,6 @@ module Katello
       has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy, :inverse_of => :subscription_facet
       has_many :activation_keys, :through => :subscription_facet_activation_keys, :class_name => "Katello::ActivationKey"
 
-      has_many :subscription_facet_purpose_addons, :class_name => "Katello::SubscriptionFacetPurposeAddon", :dependent => :destroy, :inverse_of => :subscription_facet
-      has_many :purpose_addons, :class_name => "Katello::PurposeAddon", :through => :subscription_facet_purpose_addons
-
       has_many :subscription_facet_pools, :class_name => "Katello::SubscriptionFacetPool", :dependent => :delete_all, :inverse_of => :subscription_facet
       has_many :pools, :through => :subscription_facet_pools, :class_name => "Katello::Pool"
 
@@ -27,9 +24,7 @@ module Katello
 
       DEFAULT_TYPE = 'system'.freeze
 
-      accepts_nested_attributes_for :installed_products, :purpose_addons
-
-      dirty_has_many_associations :purpose_addons
+      accepts_nested_attributes_for :installed_products
 
       attr_accessor :facts
 
@@ -63,9 +58,6 @@ module Katello
         self.update_installed_products(consumer_params['installedProducts']) if consumer_params.key?('installedProducts')
         self.purpose_role = consumer_params['role'] unless consumer_params['role'].nil?
         self.purpose_usage = consumer_params['usage'] unless consumer_params['usage'].nil?
-        unless consumer_params['addOns'].nil?
-          self.purpose_addon_ids = consumer_params['addOns'].map { |addon_name| ::Katello::PurposeAddon.find_or_create_by(name: addon_name).id }
-        end
 
         unless consumer_params['releaseVer'].nil?
           release = consumer_params['releaseVer']
@@ -141,7 +133,6 @@ module Katello
           :autoheal => autoheal,
           :usage => purpose_usage,
           :role => purpose_role,
-          :addOns => purpose_addons.pluck(:name),
           :serviceLevel => service_level,
           :releaseVer => release_version,
           :environments => self.candlepin_environments,
@@ -283,7 +274,7 @@ module Katello
       end
 
       def backend_update_needed?
-        %w(release_version service_level autoheal purpose_role purpose_usage purpose_addon_ids).each do |method|
+        %w(release_version service_level autoheal purpose_role purpose_usage).each do |method|
           if self.send("#{method}_changed?")
             Rails.logger.debug("backend_update_needed: subscription facet #{method} changed")
             return true
@@ -302,10 +293,11 @@ module Katello
         return unless host.subscription_facet || has_convert2rhel
         # Add in custom convert2rhel fact if system was converted using convert2rhel through Katello
         # We want the value nil unless the custom fact is present otherwise we get a 0 in the database which if debugging
-        # might make you think it was converted2rhel but not with satellite, that is why I have the tenary below.
+        # might make you think it was converted2rhel but not with satellite, that is why I have the ternary below.
         facet = host.subscription_facet || host.build_subscription_facet
         facet.attributes = {
           convert2rhel_through_foreman: has_convert2rhel ? ::Foreman::Cast.to_bool(parser.facts['conversions.env.CONVERT2RHEL_THROUGH_FOREMAN']) : nil,
+
         }.compact
         facet.save unless facet.new_record?
       end

data/app/models/katello/repository.rb

@@ -357,6 +357,13 @@ module Katello
       end
     end
 
+    def full_gpg_key_path(smart_proxy = nil, force_http = false)
+      return if self.root.gpg_key.try(:content).blank?
+      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : ::SmartProxy.pulp_primary.url)
+      scheme = force_http ? 'http' : 'https'
+      "#{scheme}://#{pulp_uri.host.downcase}#{gpg_key_content_api_repository_url(self, :only_path => true)}"
+    end
+
     def product_type
       redhat? ? "redhat" : "custom"
     end
@@ -556,9 +563,9 @@ module Katello
         view = self.content_view.label
         product = self.product.label
         env = cve.label.split('/').first
-        "#{org}-#{env.downcase}-#{view}-#{product}-#{self.root.label}"
+        "#{org}/#{env.downcase}/#{view}/#{product}/#{self.root.label}"
       else
-        "#{org}-#{self.content_view.label}-#{self.content_view_version.version}-#{self.root.product.label}-#{self.root.label}"
+        "#{org}/#{self.content_view.label}/#{self.content_view_version.version}/#{self.root.product.label}/#{self.root.label}"
       end
     end
 
@@ -697,7 +704,7 @@ module Katello
                           .uniq
                           .map { |task| "- #{Setting['foreman_url']}/foreman_tasks/tasks/#{task&.id}" }
                           .join("\n")
-        fail _("This repository has pending tasks in associated content views. Please wait for the tasks: " + errored_tasks +
+        fail _("Repository #{self.label} has pending tasks in associated content views. Please wait for the tasks: " + errored_tasks +
                " to complete before proceeding.")
       end
     end
@@ -936,9 +943,9 @@ module Katello
       # the container provided. Branches numbered as ordered below.
       #
       # 1 - Render promotion pattern (or env pattern if no promo pattern)
-      # 2 - <org label>-<product label>-<repo label>
-      # 3 - <org label>-<env label>-<cv label>-<product label>-<repo label>
-      # 4 - <org label>-<cv label>-<cvv label>-<product label>-<repo label>
+      # 2 - <org label>/<product label>/<repo label>
+      # 3 - <org label>/<env label>/<cv label>/<product label>/<repo label>
+      # 4 - <org label>/<cv label>/<cvv label>/<product label>/<repo label>
       is_pattern_provided = pattern.present?
       env_exists = repository.environment.present?
       is_env_pattern_provided = env_exists && repository.environment.registry_name_pattern.present?
@@ -967,7 +974,7 @@ module Katello
       else
         items = [repository.organization.label, repository.content_view.label, repository.content_view_version.version, repository.product.label, repository.label]
       end
-      Repository.clean_container_name(items.compact.join("-"))
+      Repository.clean_container_name(items.compact.join("/"))
     end
 
     def self.clean_container_name(name)
@@ -1052,10 +1059,16 @@ module Katello
       pulp_api.list({:repository_version => version_href}).results.map { |x| x.component }.uniq
     end
 
+    def deb_sanitize_pulp_distribution(distribution)
+      return "flat-repo" if distribution == "/"
+      return distribution.chomp("/") if distribution&.end_with?("/")
+      distribution
+    end
+
     def deb_pulp_distributions(version_href = self.version_href)
       return [] if version_href.blank?
       pulp_api = Katello::Pulp3::Repository.instance_for_type(self, SmartProxy.pulp_primary).api.content_release_components_api
-      pulp_api.list({:repository_version => version_href}).results.map { |x| x.distribution }.uniq
+      pulp_api.list({:repository_version => version_href}).results.map { |x| deb_sanitize_pulp_distribution(x.distribution) }.uniq
     end
 
     def sync_status

data/app/models/katello/rhel_lifecycle_status.rb

@@ -13,6 +13,9 @@ module Katello
     end
 
     RHEL_EOS_SCHEDULE = { # dates that each support category ends
+      'RHEL10' => {
+        'full_support' => nil,
+      },
       'RHEL9' => {
         'full_support' => end_of_day('2027-05-31'),
         'maintenance_support' => end_of_day('2032-05-31'),
@@ -74,6 +77,7 @@ module Katello
 
     def self.lifecycles_expire_soon
       expiring = RHEL_EOS_SCHEDULE.collect do |index, schedules|
+        next if schedules['full_support'].blank?
         expire_soon = schedules.except("full_support").select { |_k, v| (Time.now.utc..Time.now.utc + EOS_WARNING_THRESHOLD).cover?(v) }
         {index => expire_soon} if expire_soon.present?
       end
@@ -98,6 +102,8 @@ module Katello
       extended_support_end_date = RHEL_EOS_SCHEDULE[release]['extended_support']
 
       case
+      when full_support_end_date.blank?
+        return FULL_SUPPORT
       when Date.today <= full_support_end_date
         return FULL_SUPPORT
       when Date.today <= maintenance_support_end_date

data/app/models/katello/root_repository.rb

@@ -23,7 +23,7 @@ module Katello
     SKIPABLE_METADATA_TYPES = [Repository::YUM_TYPE, Repository::DEB_TYPE].freeze
 
     CONTENT_ATTRIBUTE_RESTRICTIONS = {
-      :download_policy => [Repository::YUM_TYPE, Repository::DEB_TYPE, Repository::DOCKER_TYPE],
+      :download_policy => [Repository::YUM_TYPE, Repository::DEB_TYPE, Repository::DOCKER_TYPE, Repository::FILE_TYPE],
     }.freeze
 
     MAX_EXPIRE_TIME = 7 * 24 * 60 * 60
@@ -39,7 +39,8 @@ module Katello
     RHEL7 = 'rhel-7'.freeze
     RHEL8 = 'rhel-8'.freeze
     RHEL9 = 'rhel-9'.freeze
-    ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8, RHEL9].freeze
+    RHEL10 = 'rhel-10'.freeze
+    ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8, RHEL9, RHEL10].freeze
 
     MIRRORING_POLICY_ADDITIVE = 'additive'.freeze
     MIRRORING_POLICY_CONTENT = 'mirror_content_only'.freeze
@@ -218,12 +219,6 @@ module Katello
       ::Host.joins(:content_facet => :bound_repositories).where("#{Katello::Repository.table_name}.root_id" => self.select(:id))
     end
 
-    def ensure_no_download_policy
-      if !yum? && download_policy.present?
-        errors.add(:download_policy, _("cannot be set for non-yum repositories."))
-      end
-    end
-
     def ensure_no_checksum_on_demand
       if checksum_type.present? && download_policy == DOWNLOAD_ON_DEMAND
         errors.add(:checksum_type, _("Checksum type cannot be set for yum repositories with on demand download policy."))

data/app/overrides/add_organization_attributes.rb

@@ -11,6 +11,12 @@ Deface::Override.new(:virtual_path => "taxonomies/_form",
                      :text => '<% if taxonomy.is_a?(Location) %><%= render_original %><% end %>'
                     )
 
+Deface::Override.new(:virtual_path => "taxonomies/_step1",
+                    :name => "add_organization_attributes_on_create",
+                    :insert_after => 'erb[loud]:contains("text_f"):contains(":name")',
+                    :partial => 'overrides/organizations/step_1_override'
+                    )
+
 # Add organization attributes to org edit
 Deface::Override.new(:virtual_path => "taxonomies/_form",
                      :name => "add_organization_attributes_on_edit",

data/app/services/katello/product_content_finder.rb

@@ -26,7 +26,8 @@ module Katello
       structured_apt_roots = roots.where(:content_id => nil)
       if structured_apt_roots.any?
         deb_repos_query = Katello::Repository.where(root: structured_apt_roots)
-        deb_repos = match_environment ? deb_repos_query.where(content_view_version: versions, environment: consumable.environment) : deb_repos_query.where(:library_instance_id => nil)
+        environment = consumable.respond_to?(:environment) ? consumable.environment : consumable.content_view_environments.select(:environment_id).map(&:environment_id)
+        deb_repos = match_environment ? deb_repos_query.where(content_view_version: versions, environment: environment) : deb_repos_query.where(:library_instance_id => nil)
         content_ids += deb_repos.pluck(:content_id)
       end
 

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

@@ -29,8 +29,9 @@ module Katello
           pulp_id: unit[unit_identifier],
           annotations: unit['annotations'],
           labels: unit['labels'],
-          is_bootable: unit['is_bootable'],
-          is_flatpak: unit['is_flatpak'],
+          is_bootable: unit['is_bootable'] || unit['type'] == 'bootable',
+          is_flatpak: unit['is_flatpak'] || unit['type'] == 'flatpak',
+          content_type: unit['type'],
         }
       end
     end

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

@@ -31,8 +31,9 @@ module Katello
           pulp_id: unit[unit_identifier],
           annotations: unit['annotations'],
           labels: unit['labels'],
-          is_bootable: unit['is_bootable'],
-          is_flatpak: unit['is_flatpak'],
+          is_bootable: unit['is_bootable'] || unit['type'] == 'bootable',
+          is_flatpak: unit['is_flatpak'] || unit['type'] == 'flatpak',
+          content_type: unit['type'],
         }
       end
 

data/app/services/katello/pulp3/repository/ansible_collection.rb

@@ -13,7 +13,8 @@ module Katello
                                       requirements_file: root.ansible_collection_requirements.blank? ? nil : root.ansible_collection_requirements,
                                       auth_url: root.ansible_collection_auth_url,
                                       token: root.ansible_collection_auth_token,
-                                      tls_validation: root.verify_ssl_on_sync)
+                                      tls_validation: root.verify_ssl_on_sync,
+                                      sync_dependencies: root.sync_dependencies)
         end
 
         def distribution_options(path)
@@ -28,6 +29,12 @@ module Katello
           "/pulp_ansible/galaxy/#{repo.relative_path}/api/"
         end
 
+        def sync_url_params(sync_options)
+          params = super
+          params[:optimize] = sync_options[:optimize] if sync_options.key?(:optimize)
+          params
+        end
+
         def mirror_remote_options
           {
           }

data/app/services/katello/pulp3/repository/apt.rb

@@ -226,23 +226,6 @@ module Katello
           multi_copy_units(repo_id_map, dependency_solving)
         end
 
-        def copy_units(content_unit_hrefs, remove_all)
-          remove_all = true if remove_all.nil?
-          tasks = []
-
-          if content_unit_hrefs.sort!.any?
-            first_slice = remove_all
-            content_unit_hrefs.each_slice(UNIT_LIMIT) do |slice|
-              tasks << add_content(slice, first_slice)
-              first_slice = false
-            end
-          # If we're merging composite cv repositories, don't clear out the Pulp repository.
-          elsif remove_all
-            tasks << remove_all_content
-          end
-          tasks
-        end
-
         def copy_content_for_source(source_repository, options = {})
           # copy_units_by_href(source_repository.debs.pluck(:pulp_id))
           filters = ContentViewDebFilter.where(:id => options[:filter_ids])
@@ -261,7 +244,22 @@ module Katello
 
           content_unit_hrefs = whitelist_ids - blacklist_ids
 
-          copy_units(content_unit_hrefs.uniq, options[:remove_all])
+          pulp_deb_copy_serializer = PulpDebClient::Copy.new
+          pulp_deb_copy_serializer.dependency_solving = false
+          pulp_deb_copy_serializer.config = [{
+            source_repo_version: source_repository.version_href,
+            dest_repo: repository_reference.repository_href,
+            content: content_unit_hrefs,
+          }]
+
+          remove_all = options[:remove_all]
+          remove_all = true if remove_all.nil?
+
+          if remove_all
+            remove_all_content_from_repo(repository_reference.repository_href)
+          end
+
+          copy_content_chunked(pulp_deb_copy_serializer)
         end
 
         def regenerate_applicability

data/app/services/katello/pulp3/repository/file.rb

@@ -17,12 +17,14 @@ module Katello
         end
 
         def remote_options
+          options = common_remote_options
           #TODO: move to user specifying PULP_MANIFEST
           if root.url.blank?
-            common_remote_options.merge(url: nil)
+            options[:url] = nil
           else
-            common_remote_options.merge(url: root.url + '/PULP_MANIFEST')
+            options[:url] = root.url + '/PULP_MANIFEST'
           end
+          options.merge!(policy: root.download_policy)
         end
 
         def partial_repo_path

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

@@ -136,6 +136,10 @@ module Katello
         RepositoryMirror.new(self).refresh_entities
       end
 
+      def refresh_entities
+        [update_remote].flatten.compact
+      end
+
       def refresh_if_needed
         tasks = []
         tasks << update_remote #always update remote