katello 3.16.0.rc5.1 → 3.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c713303404ad8912ded54dd3d110d6ef3f8e1ed9500f55abf1f31f2180d08a2
-  data.tar.gz: 07eb7edbe97e87b35d0ebd26eb90c0da64a8eddb69d4435333a546eaa82d298b
+  metadata.gz: 3c1b5ae508e6d13abb97dd4fa5dcb3a869b5a8ee2f6a2a2e574bcde16faa1c41
+  data.tar.gz: e5dc1c88a336020bf333e9f781eac5790b588139bd8d813433bea739ee7077ca
 SHA512:
-  metadata.gz: 67508f99358a420af1f1fbdb332e427bec5ee59092c69f05790029be0d14b624f6306dc351c550f02671819add178da8ae92938aeb2f66a262bebbd287cbad66
-  data.tar.gz: 5267fc924abe8504b4688481792f964adab5b530f2110e3bb8954717fef6a6d691635f0c64d9f2a56b7bf311620df1b5cde767e9e9d2894ad454d134552f9425
+  metadata.gz: c6e0279e68e389701bcf84815bd401fe64375259da0ff533e4ae53fbf51f99b93837be754c0fb8d2d0457e6a8d299e4527c26d5c51fb4e81870f78592bbd46bf
+  data.tar.gz: 2296caf477bbb72d78f187e53a493b9e4c8657119424939063a8a6c6c40435d5e9bda70490351101207694cf9511a59de939397c53c623f11a2f30eba564ff91

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

@@ -6,8 +6,8 @@ module Katello
     before_action :confirm_push_settings, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
                                                  :chunk_upload_blob, :push_manifest]
     skip_before_action :authorize
-    before_action :optional_authorize, only: [:token]
-    before_action :registry_authorize, except: [:token, :v1_search]
+    before_action :optional_authorize, only: [:token, :catalog]
+    before_action :registry_authorize, except: [:token, :v1_search, :catalog]
     before_action :authorize_repository_read, only: [:pull_manifest, :tags_list]
     before_action :authorize_repository_write, only: [:push_manifest]
     skip_before_action :check_content_type, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
@@ -39,20 +39,7 @@ module Katello
                                              "scope=\"repository:registry:pull,push\""
     end
 
-    def optional_authorize
-      @repository = find_scope_repository
-      if @repository && (@repository.environment.registry_unauthenticated_pull || ssl_client_authorized?(@repository.organization.label))
-        true
-      else
-        authorize
-      end
-    end
-
-    def registry_authorize
-      @repository = find_readable_repository
-      return true if ['GET', 'HEAD'].include?(request.method) && @repository && !require_user_authorization?
-
-      token = request.headers['Authorization']
+    def set_user_by_token(token, redirect_on_failure = true)
       if token
         token_type, token = token.split
         if token_type == 'Bearer' && token
@@ -63,10 +50,34 @@ module Katello
           end
         elsif token_type == 'Basic' && token
           return true if authorize
-          redirect_authorization_headers
+          redirect_authorization_headers if redirect_on_failure
           return false
         end
       end
+      false
+    end
+
+    def optional_authorize
+      @repository = find_scope_repository
+      if @repository && (@repository.environment.registry_unauthenticated_pull || ssl_client_authorized?(@repository.organization.label))
+        true
+      elsif params['action'] == 'catalog'
+        set_user_by_token(request.headers['Authorization'], false)
+      elsif (params['action'] == 'token' && params['scope'].blank? && params['account'].blank?)
+        true
+      else
+        authorize
+      end
+    end
+
+    def registry_authorize
+      @repository = find_readable_repository
+      return true if ['GET', 'HEAD'].include?(request.method) && @repository && !require_user_authorization?
+
+      is_user_set = set_user_by_token(request.headers['Authorization'])
+
+      return true if is_user_set
+
       redirect_authorization_headers
       render_error('unauthorized', :status => :unauthorized)
       return false
@@ -87,12 +98,8 @@ module Katello
     # Also include repositories in lifecycle environments with registry_unauthenticated_pull=true
     def readable_repositories
       table_name = Repository.table_name
-      in_products = Repository.in_product(Katello::Product.authorized(:view_products)).select(:id)
-      in_environments = Repository.where(:environment_id => Katello::KTEnvironment.authorized(:view_lifecycle_environments)).select(:id)
       in_unauth_environments = Repository.joins(:environment).where("#{Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true).select(:id)
-      in_content_views = Repository.joins(:content_view_repositories).where("#{ContentViewRepository.table_name}.content_view_id" => Katello::ContentView.readable).select(:id)
-      in_versions = Repository.joins(:content_view_version).where("#{Katello::ContentViewVersion.table_name}.content_view_id" => Katello::ContentView.readable).select(:id)
-      Repository.where("#{table_name}.id in (?) or #{table_name}.id in (?) or #{table_name}.id in (?) or #{table_name}.id in (?) or #{table_name}.id in (?)", in_products, in_content_views, in_versions, in_environments, in_unauth_environments)
+      Repository.readable.or(Repository.joins(:root).where("#{table_name}.id in (?)", in_unauth_environments))
     end
 
     def find_readable_repository
@@ -105,7 +112,8 @@ module Katello
     end
 
     def require_user_authorization?(repository = @repository)
-      !repository || (!repository.environment.registry_unauthenticated_pull && !ssl_client_authorized?(repository.organization.label))
+      !(params['action'] == 'token' && params['scope'].blank? && params['account'].blank?) &&
+        (!repository || (!repository.environment.registry_unauthenticated_pull && !ssl_client_authorized?(repository.organization.label)))
     end
 
     def ssl_client_authorized?(org_label)
@@ -293,6 +301,14 @@ module Katello
     end
 
     def v1_search
+      # Checks for podman client and issues a 404 in that case. Podman
+      # examines the response from a /v1_search request. If the result
+      # is a 4XX, it will then proceed with a request to /_catalog
+      if request.headers['HTTP_USER_AGENT'].downcase.include?('libpod')
+        render json: {}, status: :not_found
+        return
+      end
+
       authenticate # to set current_user, not to enforce
       options = {
         resource_class: Katello::Repository

data/app/helpers/katello/content_view_helper.rb

@@ -0,0 +1,15 @@
+module Katello
+  module ContentViewHelper
+    def separated_repo_mapping(repo_mapping)
+      separated_mapping = { :pulp3_yum => {}, :other => {} }
+      repo_mapping.each do |source_repos, dest_repo|
+        if dest_repo.content_type == "yum" && SmartProxy.pulp_master.pulp3_support?(dest_repo)
+          separated_mapping[:pulp3_yum][source_repos] = dest_repo
+        else
+          separated_mapping[:other][source_repos] = dest_repo
+        end
+      end
+      separated_mapping
+    end
+  end
+end

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

@@ -52,7 +52,9 @@ module Actions
               action = plan_action(ContentViewVersion::IncrementalUpdate, composite_version, environments,
                                    :new_components => new_components, :description => description,
                                                            :content => {:puppet_module_ids => puppet_module_ids})
-              output_for_version_ids << {:version_id => action.new_content_view_version.id, :output => action.output}
+              unless SmartProxy.pulp_master.pulp3_repository_type_support?("yum")
+                output_for_version_ids << {:version_id => action.new_content_view_version.id, :output => action.output}
+              end
             end
           end
         end

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

@@ -3,6 +3,8 @@ module Actions
   module Katello
     module ContentView
       class Publish < Actions::EntryAction
+        include ::Katello::ContentViewHelper
+        attr_accessor :version
         # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         def plan(content_view, description = "", options = {})
           action_subject(content_view)
@@ -21,7 +23,11 @@ module Actions
             end
           end
 
+          # Add non-override components back in
+          options[:override_components] = include_other_components(options[:override_components], content_view)
+
           version = version_for_publish(content_view, options)
+          self.version = version
           library = content_view.organization.library
           history = ::Katello::ContentViewHistory.create!(:content_view_version => version,
                                                           :user => ::User.current.login,
@@ -32,20 +38,30 @@ module Actions
                                                           :triggered_by => options[:triggered_by]
                                                          )
           source_repositories = []
-          content_view.publish_repositories do |repositories|
+          content_view.publish_repositories(options[:override_cvvs]) do |repositories|
             source_repositories += [repositories]
           end
 
           sequence do
-            plan_action(ContentView::AddToEnvironment, version, library)
+            plan_action(ContentView::AddToEnvironment, version, library) unless options[:skip_promotion]
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, version, source_repositories).repository_mapping
 
+            # Split Pulp 3 Yum repos out of the repository_mapping.  Only Pulp 3 RPM plugin has multi repo copy support.
+            separated_repo_map = separated_repo_mapping(repository_mapping)
+
+            if separated_repo_map[:pulp3_yum].keys.flatten.present? &&
+                SmartProxy.pulp_master.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
+              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
+            end
+
             concurrence do
               source_repositories.each do |repositories|
                 sequence do
-                  plan_action(Repository::CloneToVersion, repositories, version, repository_mapping[repositories],
-                                                 :repos_units => options[:repos_units])
-                  plan_action(Repository::CloneToEnvironment, repository_mapping[repositories], library)
+                  if repositories.present? && separated_repo_map[:other].keys.include?(repositories)
+                    plan_action(Repository::CloneToVersion, repositories, version, repository_mapping[repositories],
+                                :repos_units => options[:repos_units])
+                  end
+                  plan_action(Repository::CloneToEnvironment, repository_mapping[repositories], library) unless options[:skip_promotion]
                 end
               end
 
@@ -55,16 +71,18 @@ module Actions
             end
             has_modules = content_view.publish_puppet_environment?
             plan_action(ContentViewPuppetEnvironment::CreateForVersion, version)
-            plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
-                :puppet_modules_present => has_modules)
-            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library))
-            plan_action(Katello::Foreman::ContentUpdate, library, content_view)
-            plan_action(ContentView::ErrataMail, content_view, library)
+            unless options[:skip_promotion]
+              plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
+                  :puppet_modules_present => has_modules)
+            end
+            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library)) unless options[:skip_promotion]
+            plan_action(Katello::Foreman::ContentUpdate, library, content_view) unless options[:skip_promotion]
+            plan_action(ContentView::ErrataMail, content_view, library) unless options[:skip_promotion]
             plan_self(history_id: history.id, content_view_id: content_view.id,
                       auto_publish_composite_ids: auto_publish_composite_ids(content_view),
                       content_view_version_name: version.name,
                       content_view_version_id: version.id,
-                      environment_id: library.id, user_id: ::User.current.id)
+                      environment_id: library.id, user_id: ::User.current.id, skip_promotion: options[:skip_promotion])
           end
         end
 
@@ -85,6 +103,7 @@ module Actions
 
           output[:content_view_id] = input[:content_view_id]
           output[:content_view_version_id] = input[:content_view_version_id]
+          output[:skip_promotion] = input[:skip_promotion]
         end
 
         def rescue_strategy_for_self
@@ -95,9 +114,11 @@ module Actions
           version = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
           version.update_content_counts!
           # update errata applicability counts for all hosts in the CV & Library
-          ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
-                                              :lifecycle_environment_id => input[:environment_id]).each do |facet|
-            facet.update_applicability_counts
+          unless input[:skip_promotion]
+            ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
+                                                :lifecycle_environment_id => input[:environment_id]).each do |facet|
+              facet.update_applicability_counts
+            end
           end
 
           history = ::Katello::ContentViewHistory.find(input[:history_id])
@@ -105,7 +126,7 @@ module Actions
           history.save!
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           view = ::Katello::ContentView.find(input[:content_view_id])
-          if SmartProxy.sync_needed?(environment) && Setting[:foreman_proxy_content_auto_sync]
+          if SmartProxy.sync_needed?(environment) && Setting[:foreman_proxy_content_auto_sync] && !input[:skip_promotion]
             ForemanTasks.async_task(ContentView::CapsuleSync,
                                     view,
                                     environment)
@@ -115,6 +136,20 @@ module Actions
 
         private
 
+        def include_other_components(override_components, content_view)
+          if override_components.present?
+            content_view.components.each do |component|
+              component_has_override = override_components.detect do |override_component|
+                component.content_view_id == override_component.content_view_id
+              end
+              unless component_has_override
+                override_components << component
+              end
+            end
+            override_components
+          end
+        end
+
         def repos_to_delete(content_view)
           if content_view.composite?
             library_instances = content_view.repositories_to_publish.map(&:library_instance_id)
@@ -132,7 +167,11 @@ module Actions
 
         def version_for_publish(content_view, options)
           if options[:minor] && options[:major]
-            content_view.create_new_version(options[:major], options[:minor])
+            if options[:override_components]
+              content_view.create_new_version(options[:major], options[:minor], options[:override_components])
+            else
+              content_view.create_new_version(options[:major], options[:minor])
+            end
           else
             content_view.create_new_version
           end

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

@@ -1,7 +1,9 @@
 module Actions
   module Katello
     module ContentViewVersion
+      # rubocop:disable Metrics/ClassLength
       class IncrementalUpdate < Actions::EntryAction
+        include ::Katello::ContentViewHelper
         attr_accessor :new_content_view_version
 
         HUMANIZED_TYPES = {
@@ -30,6 +32,19 @@ module Actions
           validate_environments(environments, old_version)
 
           new_minor = old_version.content_view.versions.where(:major => old_version.major).maximum(:minor) + 1
+          if SmartProxy.pulp_master.pulp3_repository_type_support?("yum") && is_composite
+            sequence do
+              publish_action = plan_action(::Actions::Katello::ContentView::Publish, old_version.content_view, description,
+                          :major => old_version.major, :minor => new_minor,
+                          :override_components => new_components, :skip_promotion => true)
+              if old_version.environments.present?
+                plan_action(::Actions::Katello::ContentView::Promote, publish_action.version,
+                            old_version.environments, true, description)
+              end
+            end
+            return
+          end
+
           self.new_content_view_version = old_version.content_view.create_new_version(old_version.major, new_minor, all_components)
           history = ::Katello::ContentViewHistory.create!(:content_view_version => new_content_view_version, :user => ::User.current.login,
                                                           :action => ::Katello::ContentViewHistory.actions[:publish],
@@ -41,6 +56,7 @@ module Actions
 
           sequence do
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, new_content_view_version, repos_to_clone).repository_mapping
+            separated_repo_map = separated_repo_mapping(repository_mapping)
 
             repos_to_clone.each do |source_repos|
               plan_action(Repository::CloneToVersion,
@@ -51,18 +67,24 @@ module Actions
             end
 
             concurrence do
-              if SmartProxy.pulp_master.pulp3_support?(repos_to_clone.first.first)
-                extended_repo_mapping = pulp3_repo_mapping(repository_mapping, old_version)
+              if separated_repo_map[:pulp3_yum].keys.flatten.present?
+                extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum], old_version)
                 unit_map = pulp3_content_mapping(content)
 
-                copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
-                                                   dependency_solving: true).output
-              else
+                unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
+                  copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
+                                                     dependency_solving: true).output
+                end
+              end
+
+              if separated_repo_map[:other].keys.flatten.present?
                 repos_to_clone.each do |source_repos|
-                  copy_action_outputs += copy_repos(repository_mapping[source_repos],
-                                                    new_content_view_version,
-                                                    content,
-                                                    dep_solve)
+                  if separated_repo_map[:other].keys.include?(source_repos)
+                    copy_action_outputs += copy_repos(repository_mapping[source_repos],
+                                                      new_content_view_version,
+                                                      content,
+                                                      dep_solve)
+                  end
                 end
               end
 
@@ -98,11 +120,21 @@ module Actions
 
         def pulp3_repo_mapping(repo_mapping, old_version)
           pulp3_repo_mapping = {}
-          repo_mapping.each do |source_repo, dest_repo|
-            source_repo = source_repo.first.library_instance? ? source_repo : [source_repo.first.library_instance]
-            pulp3_repo_mapping[source_repo.first.id] = { dest_repo: dest_repo.id,
-                                                         base_version: pulp3_dest_base_version(
-                                                           ::Katello::ContentViewVersion.find(old_version.id), dest_repo) }
+          repo_mapping.each do |source_repos, dest_repo|
+            old_version_repo = old_version.repositories.archived.find_by(root_id: dest_repo.root_id)
+
+            next if old_version_repo.version_href == old_version_repo.library_instance.version_href
+
+            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
+              base_version = 0
+            end
+
+            pulp3_repo_mapping[source_repos.map(&:id)] = { dest_repo: dest_repo.id, base_version: base_version }
           end
           pulp3_repo_mapping
         end
@@ -179,42 +211,44 @@ module Actions
           base_repos = ::Katello::ContentViewVersion.find(input[:old_version]).repositories
           new_repos = ::Katello::ContentViewVersion.find(input[:new_content_view_version_id]).repositories
 
-          if input[:copy_action_outputs].last[:pulp_tasks].last[:pulp_href]&.include?("/pulp/api/v3/")
-            new_repos.each do |new_repo|
-              matched_old_repo = base_repos.where(root_id: new_repo.root_id).first
+          if input[:copy_action_outputs].present? && input[:copy_action_outputs].last[:pulp_tasks].present?
+            if input[:copy_action_outputs].last[:pulp_tasks].last[:pulp_href]&.include?("/pulp/api/v3/")
+              new_repos.each do |new_repo|
+                matched_old_repo = base_repos.where(root_id: new_repo.root_id).first
 
-              new_errata = new_repo.errata - matched_old_repo.errata
-              new_module_streams = new_repo.module_streams - matched_old_repo.module_streams
-              new_rpms = new_repo.rpms - matched_old_repo.rpms
+                new_errata = new_repo.errata - matched_old_repo.errata
+                new_module_streams = new_repo.module_streams - matched_old_repo.module_streams
+                new_rpms = new_repo.rpms - matched_old_repo.rpms
 
-              new_errata.each do |erratum|
-                content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
-              end
-              new_module_streams.each do |module_stream|
-                content[::Katello::ModuleStream::CONTENT_TYPE] <<
-                  "#{module_stream.name}:#{module_stream.stream}:#{module_stream.version}"
-              end
-              new_rpms.each do |rpm|
-                content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
+                new_errata.each do |erratum|
+                  content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
+                end
+                new_module_streams.each do |module_stream|
+                  content[::Katello::ModuleStream::CONTENT_TYPE] <<
+                    "#{module_stream.name}:#{module_stream.stream}:#{module_stream.version}"
+                end
+                new_rpms.each do |rpm|
+                  content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
+                end
               end
-            end
-          else
-            input[:copy_action_outputs].each do |copy_output|
-              copy_output[:pulp_tasks].each do |pulp_task|
-                pulp_task[:result][:units_successful].each do |unit|
-                  type = unit['type_id']
-                  unit = unit['unit_key']
-                  case type
-                  when ::Katello::Erratum::CONTENT_TYPE
-                    content[::Katello::Erratum::CONTENT_TYPE] << unit['id']
-                  when ::Katello::ModuleStream::CONTENT_TYPE
-                    content[::Katello::ModuleStream::CONTENT_TYPE] << "#{unit['name']}:#{unit['stream']}:#{unit['version']}"
-                  when ::Katello::Rpm::CONTENT_TYPE
-                    content[::Katello::Rpm::CONTENT_TYPE] << ::Katello::Util::Package.build_nvra(unit)
-                  when ::Katello::Deb::CONTENT_TYPE
-                    content[::Katello::Deb::CONTENT_TYPE] << "#{unit['name']}_#{unit['version']}_#{unit['architecture']}"
-                  when ::Katello::PuppetModule::CONTENT_TYPE
-                    content[::Katello::PuppetModule::CONTENT_TYPE] << "#{unit['author']}-#{unit['name']}-#{unit['version']}"
+            else
+              input[:copy_action_outputs].each do |copy_output|
+                copy_output[:pulp_tasks].each do |pulp_task|
+                  pulp_task[:result][:units_successful].each do |unit|
+                    type = unit['type_id']
+                    unit = unit['unit_key']
+                    case type
+                    when ::Katello::Erratum::CONTENT_TYPE
+                      content[::Katello::Erratum::CONTENT_TYPE] << unit['id']
+                    when ::Katello::ModuleStream::CONTENT_TYPE
+                      content[::Katello::ModuleStream::CONTENT_TYPE] << "#{unit['name']}:#{unit['stream']}:#{unit['version']}"
+                    when ::Katello::Rpm::CONTENT_TYPE
+                      content[::Katello::Rpm::CONTENT_TYPE] << ::Katello::Util::Package.build_nvra(unit)
+                    when ::Katello::Deb::CONTENT_TYPE
+                      content[::Katello::Deb::CONTENT_TYPE] << "#{unit['name']}_#{unit['version']}_#{unit['architecture']}"
+                    when ::Katello::PuppetModule::CONTENT_TYPE
+                      content[::Katello::PuppetModule::CONTENT_TYPE] << "#{unit['author']}-#{unit['name']}-#{unit['version']}"
+                    end
                   end
                 end
               end
@@ -315,10 +349,6 @@ module Actions
           copy_outputs
         end
 
-        def pulp3_dest_base_version(old_cvv, new_repo)
-          old_cvv.repositories.archived.find_by(root_id: new_repo.root_id).version_href.split("/")[-1].to_i
-        end
-
         def copy_yum_content(new_repo, dep_solve, package_ids, errata_ids)
           copy_outputs = []
           if new_repo.content_type == ::Katello::Repository::YUM_TYPE