katello 4.3.0.rc3 → 4.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa69b2700d8537140c39e127e5e94f121aeead00124eeddd6c2e7fa94e9fed32
-  data.tar.gz: 67ff63f7def7af9ed99bf7e73d14aa6e82cb41bd65ca73d4ec0fdd8867b2285d
+  metadata.gz: f1a33ac3431921424a7d17bcd6f90afbb0f0ed372e6c7873ea1b2afa35cde5d2
+  data.tar.gz: 864c45929eea0df21199da1bafc4598f504887578c8c7fa860e3d03729fcf0aa
 SHA512:
-  metadata.gz: 7b8d403df79ab4e58b40d3bb675c9908f5bae448d03e410c0fb256eaa974a043c80f8bcc371ceb9e2827311cd138f8bf209f255c3a3c295f6294af6b0799b69f
-  data.tar.gz: 469abe1ecd5ae6ce1117c9978fa3d9a1bf3dd2ad8e775de21bc6c61ba4d394e338ccec4b12e1d6226293189dfc2965f68c4377a6a5911130f1d723da14524516
+  metadata.gz: 938cb19362f4c5add3bd334c4889a95462a2c3f071a2d3764a43c59bfeac6bef1bb036f99b0d168dbf10953664e7fc5f8623f6b4a0a09021be7e9f1931b8be64
+  data.tar.gz: bb12015598a2ac15cfbd0aad5f9a18d7c86142c8157e73cf134a22b93470d0da64c977c59fb74fb2819ad5e2c15b8f77f0b1283d0b9a674205bd1e0f6ac9dc89

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

@@ -76,7 +76,7 @@ module Katello
 
     api :PUT, "/content_view_versions/:id/republish_repositories", N_("Forces a republish of the version's repositories' metadata")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
-    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use mirror on sync."), :required => true
+    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use the 'Complete Mirroring' mirroring policy"), :required => true
     def republish_repositories
       unless ::Foreman::Cast.to_bool(params[:force])
         fail HttpErrors::BadRequest, _("Metadata republishing must be forced because it is a dangerous operation.")

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

@@ -7,7 +7,7 @@ module Katello
       generic_repo_wrap_params << option.name
     end
 
-    repo_wrap_params = RootRepository.attribute_names.concat([:ignore_global_proxy]) + generic_repo_wrap_params
+    repo_wrap_params = RootRepository.attribute_names.concat([:ignore_global_proxy, :mirror_on_sync]) + generic_repo_wrap_params
 
     wrap_parameters :repository, :include => repo_wrap_params
 
@@ -53,7 +53,8 @@ module Katello
       param :docker_tags_whitelist, Array, :desc => N_("Comma-separated list of tags to sync for Container Image repository")
       param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum repos (either 'immediate' or 'on_demand')")
       param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
-      param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed")
+      param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed (Deprecated)")
+      param :mirroring_policy, Katello::RootRepository::MIRRORING_POLICIES, :desc => N_("Policy to set for mirroring content.  Must be one of %s.") % RootRepository::MIRRORING_POLICIES
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
       param :upstream_username, String, :desc => N_("Username of the upstream repository user used for authentication")
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
@@ -268,7 +269,7 @@ module Katello
 
     api :PUT, "/repositories/:id/republish", N_("Forces a republish of the specified repository, regenerating metadata and symlinks on the filesystem.")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
-    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use mirror on sync."), :required => true
+    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use the 'Complete Mirroring' mirroring policy."), :required => true
     def republish
       unless ::Foreman::Cast.to_bool(params[:force])
         fail HttpErrors::BadRequest, _('Metadata republishing must be forced because it is a dangerous operation.')
@@ -501,7 +502,7 @@ module Katello
 
     # rubocop:disable Metrics/CyclomaticComplexity
     def repository_params
-      keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password,
+      keys = [:download_policy, :mirror_on_sync, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
               :upstream_username, :download_concurrency, :upstream_authentication_token,
               {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
               :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
@@ -525,7 +526,8 @@ module Katello
         keys += [:url, :gpg_key_id, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :unprotected, :name,
                  :checksum_type]
       end
-      params.require(:repository).permit(*keys).to_h.with_indifferent_access
+      to_return = params.require(:repository).permit(*keys).to_h.with_indifferent_access
+      handle_mirror_on_sync(to_return)
     end
 
     def get_content_credential(repo_params, content_type)
@@ -545,8 +547,8 @@ module Katello
                                                             :checksum_type, :download_policy, :http_proxy_policy).to_h.with_indifferent_access)
       root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
       root.docker_tags_whitelist = repo_params.fetch(:docker_tags_whitelist, []) if root.docker?
-      root.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
+      root.mirroring_policy = repo_params[:mirroring_policy] || Katello::RootRepository::MIRRORING_POLICY_CONTENT
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
       root.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
       root.upstream_authentication_token = repo_params[:upstream_authentication_token] if repo_params.key?(:upstream_authentication_token)
@@ -577,6 +579,19 @@ module Katello
     end
     # rubocop:enable Metrics/CyclomaticComplexity
 
+    def handle_mirror_on_sync(repo_params)
+      if !repo_params.key?(:mirroring_policy) && repo_params.key?(:mirror_on_sync)
+        ::Foreman::Deprecation.api_deprecation_warning("mirror_on_sync is deprecated in favor of mirroring_policy.  It will be removed in Katello 4.6.")
+        if ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync])
+          repo_params[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_CONTENT
+        else
+          repo_params[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_ADDITIVE
+        end
+      end
+      repo_params.delete(:mirror_on_sync)
+      repo_params
+    end
+
     def error_on_rh_product
       fail HttpErrors::BadRequest, _("Red Hat products cannot be manipulated.") if @product.redhat?
     end
@@ -633,7 +648,8 @@ module Katello
 
     def generic_remote_options_hash(repo_params)
       generic_remote_options = {}
-      RepositoryTypeManager.generic_remote_options(content_type: repo_params[:content_type]).each do |option|
+      content_type = @repository&.content_type || repo_params[:content_type]
+      RepositoryTypeManager.generic_remote_options(content_type: content_type).each do |option|
         generic_remote_options[option.name] = repo_params[option.name]
       end
       generic_remote_options
@@ -652,7 +668,7 @@ module Katello
     def check_import_parameters
       @repository.repository_type&.import_attributes&.each do |import_attribute|
         if import_attribute.required && params[import_attribute.api_param].blank?
-          fail HttpErrors::UnprocessableEntity, _("%s is required", import_attributes.api_param)
+          fail HttpErrors::UnprocessableEntity, _('%s is required') % import_attribute.api_param
         end
       end
     end

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

@@ -28,7 +28,7 @@ module Katello
       end
 
       def context_urls
-        super.merge(rhsm_url: rhsm_url, pulp_content_url: pulp_content_url)
+        super.merge(rhsm_url: smart_proxy.rhsm_url, pulp_content_url: smart_proxy.pulp_content_url)
       end
 
       private
@@ -43,14 +43,6 @@ module Katello
           proxy
         end
       end
-
-      def rhsm_url
-        URI(smart_proxy.rhsm_url)
-      end
-
-      def pulp_content_url
-        smart_proxy.setting(SmartProxy::PULP3_FEATURE, 'content_app_url')
-      end
     end
   end
 end

data/app/controllers/katello/remote_execution_controller.rb

@@ -47,11 +47,12 @@ module Katello
       end
 
       def inputs
-        if feature_name == 'katello_errata_install'
-          { "Errata Search Query" => "errata_id ^ (#{errata_inputs.join(',')})" }
-        elsif feature_name == 'katello_service_restart'
+        case feature_name
+        when 'katello_errata_install'
+          { :errata => errata_inputs }
+        when 'katello_service_restart'
           { :helper => params[:name] }
-        elsif feature_name == 'katello_module_stream_action'
+        when 'katello_module_stream_action'
           fail HttpErrors::NotFound, _('module streams not found') if params[:module_spec].blank?
           fail HttpErrors::NotFound, _('actions not found') if params[:module_stream_action].blank?
           inputs = { :module_spec => params[:module_spec], :action => params[:module_stream_action] }

data/app/graphql/types/host_collection.rb

@@ -0,0 +1,18 @@
+module Types
+  class HostCollection < BaseObject
+    description "A collection of hosts"
+    model_class ::Katello::HostCollection
+
+    global_id_field :id
+    timestamps
+    field :name, String
+    field :description, String
+    field :max_hosts, Integer
+    field :unlimited_hosts, Boolean
+    has_many :hosts, Types::Host
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'Katello::HostCollection') }
+    end
+  end
+end

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

@@ -40,7 +40,7 @@ module Actions
             pulp_repo = repo.backend_service(smart_proxy)
             if !current_repos_on_capsule_ids.include?(repo.id)
               pulp_repo.create_mirror_entities
-            elsif pulp_repo.mirror_needs_updates?
+            else
               tasks += pulp_repo.refresh_mirror_entities
             end
           end

data/app/lib/actions/katello/content_view/publish.rb

@@ -200,6 +200,11 @@ module Actions
                 plan_action(Katello::Repository::IndexContent, id: id, full_index: true)
               end
             end
+            concurrence do
+              version.importable_repositories.each do |repo|
+                plan_action(::Actions::Katello::Repository::MetadataGenerate, repo)
+              end
+            end
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
           end
         end

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -72,6 +72,18 @@ module Actions
 
                 unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
                   sequence do
+                    # Pre-copy content if dest_repo is a soft copy of its library instance.
+                    # Don't use extended_repo_mapping because the source repositories are library instances.
+                    # We want the old CV snapshot repositories here so as to not pull in excess new content.
+                    separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
+                      if dest_repo.soft_copy_of_library?
+                        source_repos.each do |source_repo|
+                          # remove_all flag is set to cover the case of incrementally updating more than once with different content.
+                          # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
+                          plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+                        end
+                      end
+                    end
                     copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
                                                        dependency_solving: dep_solve).output
                     repos_to_clone.each do |source_repos|
@@ -125,10 +137,12 @@ module Actions
             source_library_repo = source_repos.first.library_instance? ? source_repos.first : source_repos.first.library_instance
 
             source_repos = [source_library_repo]
-            if old_version_repo.version_href
-              base_version = old_version_repo.version_href.split("/")[-1].to_i
-            else
+            if old_version_repo.version_href.nil?
               base_version = 0
+            elsif old_version_repo.soft_copy_of_library?
+              base_version = nil
+            else
+              base_version = old_version_repo.version_href.split("/")[-1].to_i
             end
 
             pulp3_repo_mapping[source_repos.map(&:id)] = { dest_repo: dest_repo.id, base_version: base_version }

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

@@ -113,7 +113,7 @@ module Actions
       def overwrite_pulp_error(message)
         case message
         when 'This repository uses features which are incompatible with \'mirror\' sync. Please sync without mirroring enabled.'
-          'Please disable \'mirror on sync\' because the upstream repository refers to external resources.'
+          'The "Complete Mirroring" mirroring policy is not compatible with this repository.  You may want to update it to use "Content Only"'
         else
           message
         end

data/app/lib/actions/pulp3/capsule_content/generate_metadata.rb

@@ -17,13 +17,14 @@ module Actions
 
         def invoke_external_task
           repository = ::Katello::Repository.find(input[:repository_id])
+          backend = repository.backend_service(smart_proxy).with_mirror_adapter
           #yum repositories use metadata mirroring always, so we should never
-          # regenerate metadata on proxies
-          if repository.yum?
+          # regenerate metadata on proxies.  but if there is no publication,
+          # it means the repo was likely empty and syncing didn't generate one
+          if repository.yum? && backend.publication_href.present?
             []
           else
-            smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
-            repository.backend_service(smart_proxy).with_mirror_adapter.create_publication
+            backend.create_publication
           end
         end
       end

data/app/lib/actions/pulp3/content_view_version/import.rb

@@ -19,6 +19,13 @@ module Actions
             metadata: input[:metadata]
           ).create_import(input[:importer_data][:pulp_href])
         end
+
+        def rescue_strategy_for_self
+          # There are various reasons the importing fails, not all of them are
+          # fatal: when fail on import, we continue with the task ending up
+          # in the warning state, but not locking further imports
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end

data/app/lib/actions/pulp3/orchestration/content_view_version/import.rb

@@ -15,17 +15,19 @@ module Actions
                 metadata: metadata
               ).output
 
-              import_output = plan_action(
+              plan_action(
                 ::Actions::Pulp3::ContentViewVersion::Import,
                 content_view_version_id: content_view_version.id,
                 smart_proxy_id: smart_proxy.id,
                 importer_data: importer_output[:importer_data],
                 path: path,
                 metadata: metadata
-              ).output
-
-              plan_action(Actions::Pulp3::Repository::SaveVersions, content_view_version.importable_repositories.pluck(:id),
-                          tasks: import_output[:pulp_tasks])
+              )
+              concurrence do
+                content_view_version.importable_repositories.each do |repo|
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, repo)
+                end
+              end
               plan_action(
                 ::Actions::Pulp3::ContentViewVersion::CreateImportHistory,
                 content_view_version_id: content_view_version.id,

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

@@ -13,7 +13,7 @@ module Actions
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
           service = target.backend_service(smart_proxy)
           output[:pulp_tasks] = if input[:copy_all]
-                                  service.copy_all(source, mirror: input[:mirror] || false)
+                                  service.copy_all(source, input)
                                 else
                                   service.copy_content_for_source(source, input)
                                 end

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

@@ -27,6 +27,7 @@ module Actions
               []
             else
               output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
+                                                                                repository_id: repository.id,
                                                                                 artifact: artifact_href,
                                                                                 content_type: content_type)]
             end

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

@@ -184,7 +184,7 @@ module Katello
         def net_http_class
           if proxy
             uri = URI(proxy.url) #Net::HTTP::Proxy ignores port as part of the url
-            Net::HTTP::Proxy("#{uri.host}#{uri.path}", uri.port, proxy.username, proxy.password)
+            Net::HTTP::Proxy("#{uri.host}", uri.port, proxy.username, proxy.password)
           else
             Net::HTTP
           end

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/candlepin/repository_mapper.rb

@@ -34,7 +34,7 @@ module Katello
           :content_type => katello_content_type,
           :unprotected => unprotected?,
           :download_policy => download_policy,
-          :mirror_on_sync => true
+          :mirroring_policy => Katello::RootRepository::MIRRORING_POLICY_COMPLETE
         )
 
         Repository.new(:root => root,

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

@@ -109,7 +109,7 @@ module Katello
         self.host_statuses.where(type: ::Katello::HostStatusManager::STATUSES.map(&:name)).each do |status|
           status.refresh!
         end
-        refresh_global_status!
+        refresh_global_status
       end
 
       def queue_refresh_content_host_status

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

@@ -190,7 +190,7 @@ module Katello
                 service.update_model(model, generic_content_type)
               elsif self == ::Katello::Erratum
                 # Errata will change pulp_hrefs if the upstream repo updates them
-                erratum_updated_ids << service.update_model(model)
+                erratum_updated_ids << service.update_model(model, repository)
               else
                 service.update_model(model)
               end

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

@@ -185,17 +185,17 @@ module Katello
         end
       end
 
-      def pulp3_ssl_configuration(config)
+      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
 
@@ -446,14 +446,22 @@ module Katello
       def rhsm_url
         # Since Foreman 3.1 this setting is set
         if (rhsm_url = setting(SmartProxy::PULP3_FEATURE, 'rhsm_url'))
-          rhsm_url
+          URI(rhsm_url)
         # Compatibility fall back
         elsif pulp_primary?
-          "https://#{URI.parse(url).host}/rhsm"
+          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/docker_meta_tag.rb

@@ -153,7 +153,7 @@ module Katello
         end
 
         unless params_to_query_for_delete.empty?
-          RepositoryDockerMetaTag.where(:docker_meta_tag => DockerMetaTag.where(params_to_query_for_delete.join(" OR "))).delete_all
+          RepositoryDockerMetaTag.where(:repository_id => repo.id).where(:docker_meta_tag => DockerMetaTag.where(params_to_query_for_delete.join(" OR "))).delete_all
         end
 
         metatags = []

data/app/models/katello/glue/provider.rb

@@ -1,6 +1,6 @@
 module Katello
   module Glue::Provider
-    DISTRIBUTOR_VERSION = 'sat-6.7'.freeze
+    DISTRIBUTOR_VERSION = 'sat-6.10'.freeze
 
     def self.included(base)
       base.send :include, InstanceMethods

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

@@ -136,6 +136,8 @@ module Katello
           repo_param[:download_policy] = Setting[:default_download_policy]
         end
 
+        repo_param[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_ADDITIVE if repo_param[:mirroring_policy].blank?
+
         RootRepository.new(repo_param.merge(:product_id => self.id))
       end
     end

data/app/models/katello/repository.rb

@@ -173,7 +173,7 @@ module Katello
     delegate :name, :label, :docker_upstream_name, :url, :download_concurrency, :to => :root
 
     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?",
+             :content_type, :product_id, :checksum_type, :docker_upstream_name, :mirroring_policy,
              :download_policy, :verify_ssl_on_sync, :"verify_ssl_on_sync?", :upstream_username, :upstream_password,
              :upstream_authentication_token, :deb_releases,
              :deb_components, :deb_architectures, :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id,
@@ -285,14 +285,19 @@ module Katello
       ::Katello::Resources::CDN::CdnResource.ca_file if ::Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
     end
 
-    def using_mirrored_metadata?
-      self.yum? && self.library_instance? && self.mirror_on_sync
+    def soft_copy_of_library?
+      return false if self.version_href.nil?
+      self.version_href.starts_with?(self.library_instance.backend_service(SmartProxy.pulp_primary).repository_reference.repository_href)
     end
 
     def archive?
       self.environment.nil?
     end
 
+    def using_mirrored_metadata?
+      self.yum? && self.library_instance? && self.root.mirroring_policy == Katello::RootRepository::MIRRORING_POLICY_COMPLETE
+    end
+
     def in_default_view?
       content_view_version&.default_content_view?
     end

data/app/models/katello/root_repository.rb

@@ -38,6 +38,11 @@ module Katello
     RHEL9 = 'rhel-9'.freeze
     ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8, RHEL9].freeze
 
+    MIRRORING_POLICY_ADDITIVE = 'additive'.freeze
+    MIRRORING_POLICY_CONTENT = 'mirror_content_only'.freeze
+    MIRRORING_POLICY_COMPLETE = 'mirror_complete'.freeze
+    MIRRORING_POLICIES = [MIRRORING_POLICY_ADDITIVE, MIRRORING_POLICY_COMPLETE, MIRRORING_POLICY_CONTENT].freeze
+
     belongs_to :product, :inverse_of => :root_repositories, :class_name => "Katello::Product"
     has_one :provider, :through => :product
 
@@ -74,6 +79,7 @@ module Katello
     validate :ensure_valid_authentication_token, :if => :yum?
     validate :ensure_valid_deb_constraints, :if => :deb?
     validate :ensure_no_checksum_on_demand
+    validate :ensure_valid_mirroring_policy
     validates :checksum_type, :inclusion => {:in => CHECKSUM_TYPES}, :allow_blank => true
     validates :product_id, :presence => true
     validates :content_type, :inclusion => {
@@ -107,6 +113,7 @@ module Katello
     }
     scope :orphaned, -> { where.not(id: Katello::Repository.pluck(:root_id).uniq) }
     scope :redhat, -> { joins(:provider).merge(Katello::Provider.redhat) }
+    scope :custom, -> { where.not(:id => self.redhat) }
     delegate :redhat?, :provider, :organization, to: :product
     delegate :cdn_configuration, to: :organization
 
@@ -145,6 +152,21 @@ module Katello
       end
     end
 
+    def valid_mirroring_policies
+      if self.yum?
+        MIRRORING_POLICIES
+      else
+        [MIRRORING_POLICY_ADDITIVE, MIRRORING_POLICY_CONTENT]
+      end
+    end
+
+    def ensure_valid_mirroring_policy
+      unless valid_mirroring_policies.include?(self.mirroring_policy)
+        errors.add(:mirroring_policy, _("Invalid mirroring policy for repository type %{type}, only %{policies} are valid.") %
+          {:type => self.content_type, :policies => valid_mirroring_policies.join(', ')})
+      end
+    end
+
     def ensure_valid_docker_attributes
       if (!url.blank? && docker_upstream_name.blank?)
         errors.add(:docker_upstream_name, N_("cannot be blank when Repository URL is provided."))
@@ -325,12 +347,16 @@ module Katello
       (%w(unprotected checksum_type container_repsoitory_name) & previous_changes.keys).any?
     end
 
+    def using_mirrored_content?
+      self.mirroring_policy != Katello::RootRepository::MIRRORING_POLICY_ADDITIVE
+    end
+
     def on_demand?
       self.download_policy == DOWNLOAD_ON_DEMAND
     end
 
     def pulp_update_needed?
-      changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync
+      changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirroring_policy verify_ssl_on_sync
                                  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?

data/app/services/cert/rhsm_client.rb

@@ -10,7 +10,7 @@ module Cert
     end
 
     def uuid
-      drop_cn_prefix_from_subject(@cert.subject.to_s)
+      @uuid ||= @cert.subject.to_a.detect { |name, _, _| name == 'CN' }&.second
     end
 
     private
@@ -26,10 +26,6 @@ module Cert
       end
     end
 
-    def drop_cn_prefix_from_subject(subject_string)
-      subject_string.sub(/\/CN=/i, '')
-    end
-
     def strip_cert(cert)
       cert = cert.to_s.gsub("-----BEGIN CERTIFICATE-----", "").gsub("-----END CERTIFICATE-----", "")
       cert.delete!(' ')

data/app/services/katello/component_view_presenter.rb

@@ -20,7 +20,7 @@ module Katello
         not_added_cvs = views.reject { |component_content_view| Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: component_content_view.id).first }
         not_added_cvs.map { |component_content_view| ComponentViewPresenter.new(composite_cv, nil, Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: component_content_view.id, latest: true).new) }
       else
-        views.map { |component_content_view| ComponentViewPresenter.new(cv, component_content_view) }
+        views.map { |component_content_view| ComponentViewPresenter.new(composite_cv, component_content_view) }
       end
     end
   end

data/app/services/katello/organization_creator.rb

@@ -16,7 +16,7 @@ module Katello
       User.as_anonymous_admin do
         Organization.not_created_in_katello.each do |org|
           creator = self.new(org)
-          creator.create!
+          creator.create!(raise_validation_errors: false)
         end
       end
     end
@@ -28,7 +28,9 @@ module Katello
     def seed!
       ActiveRecord::Base.transaction do
         @organization.setup_label_from_name
-        @organization.save!
+
+        # existing validation errors are not resolvable here, so don't validatate
+        @organization.save(validate: false)
 
         create_library_environment
         create_library_view
@@ -40,14 +42,19 @@ module Katello
       end
     end
 
-    def create!
+    def create!(raise_validation_errors: true)
       ActiveRecord::Base.transaction do
         seed!
 
         create_backend_objects!
 
         @organization.created_in_katello = true
-        @organization.save!
+
+        begin
+          @organization.save!
+        rescue => e
+          raise e if raise_validation_errors
+        end
       end
     end