katello 4.1.0 → 4.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f30d037b42e387abe07cb200218782b7918735e7ae3e6eff511491914e7dc4e3
-  data.tar.gz: f92e5533113942c7f23d579f53dbe1474bbf68970d1ea9c53a850e98cfb7783c
+  metadata.gz: 1adb0b8312ecc97c2044f94caff1265923f1cc909ff71a67cb95303c55658c11
+  data.tar.gz: 9a0584aad43b18d1ce26d9cd5fde0709e7b34233e005fd5fff046960a4674693
 SHA512:
-  metadata.gz: 9d408e0837a5efce7541213d3631d3d5f29dc552688cc54ca025d4add697c6443e0c6974b4bae66727eee4cbc34eb9cae37f8863b125b8725d1cdc71492480c0
-  data.tar.gz: 8ee4d0ab24c2d2525338cf6e44f54e67416682e3ce56db109d4460dd93d5bbdac7e038fa72fa9371817fa0f5ffd75ad68c3797fac3d365610ac29e3fefd7c48d
+  metadata.gz: 4a887f66325269c29a3d1413184172d357ea097031fffad680789ebbb6c5d044eeb01b053e6e570cd8eb4d8528132ee8739d2b3224b14c73b412c19389d7f144
+  data.tar.gz: b54b6cfd02c914f976b38c6b5ad586192ffb7cf146957b8b1a09626560d046ecb4683760a7c90a72cb58558a3333fe972415c401f1afb06fd4bc96414aa9a536

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

@@ -19,7 +19,9 @@ module Katello
 
       def host_setup_extension
         if params['host']['lifecycle_environment_id']
-          @host.update!(lifecycle_environment: KTEnvironment.readable.find(params['host']['lifecycle_environment_id']))
+          new_lce = KTEnvironment.readable.find(params['host']['lifecycle_environment_id'])
+          @host.content_facet.lifecycle_environment = new_lce
+          @host.update_candlepin_associations
         end
 
         super

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

@@ -10,7 +10,7 @@ module Actions
             source_repositories.each do |repositories|
               new_repository = repositories.first.build_clone(content_view: version.content_view,
                                                              version: version)
-              plan_action(Repository::Create, new_repository, true, false)
+              plan_action(Repository::Create, new_repository, clone: true)
               repository_mapping[repositories] = new_repository
             end
           end

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

@@ -18,6 +18,7 @@ module Actions
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
         def plan(old_version, environments, options = {})
           dep_solve = options.fetch(:resolve_dependencies, true)
           description = options.fetch(:description, '')
@@ -71,18 +72,22 @@ module Actions
                 unit_map = pulp3_content_mapping(content)
 
                 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: dep_solve).output
+                  sequence do
+                    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|
+                      if separated_repo_map[:pulp3_yum].keys.include?(source_repos)
+                        copy_repos(repository_mapping[source_repos])
+                      end
+                    end
+                  end
                 end
               end
 
               if separated_repo_map[:other].keys.flatten.present?
                 repos_to_clone.each do |source_repos|
                   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)
+                    copy_repos(repository_mapping[source_repos])
                   end
                 end
               end
@@ -138,19 +143,11 @@ module Actions
           end
         end
 
-        def copy_repos(new_repo, new_version, content, dep_solve)
-          copy_output = []
+        def copy_repos(new_repo)
           sequence do
-            solve_dependencies = new_version.content_view.solve_dependencies || dep_solve
-            copy_output += copy_deb_content(new_repo, solve_dependencies, content[:deb_ids])
-            copy_output += copy_yum_content(new_repo, solve_dependencies,
-                                            content[:package_ids],
-                                            content[:errata_ids])
-
             plan_action(Katello::Repository::MetadataGenerate, new_repo)
             plan_action(Katello::Repository::IndexContent, id: new_repo.id)
           end
-          copy_output
         end
 
         # For a given repo, find it's instances in both the new and old component versions.

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

@@ -10,7 +10,7 @@ module Actions
 
           sequence do
             if clone.new_record?
-              plan_action(Repository::Create, clone, true, false)
+              plan_action(Repository::Create, clone, clone: true)
             else
               #only clear if it should be empty, but its not
               plan_optional_pulp_action([Actions::Pulp::Repository::Clear], clone, SmartProxy.pulp_primary)

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

@@ -2,19 +2,18 @@ module Actions
   module Katello
     module Repository
       class Create < Actions::EntryAction
-        include Actions::Katello::PulpSelector
-
-        def plan(repository, clone = false, plan_create = false)
+        def plan(repository, args = {})
+          clone = args[:clone] || false
+          force_repo_create = args[:force_repo_create] || false
           repository.save!
           root = repository.root
 
           action_subject(repository)
 
           org = repository.organization
-          pulp2_create_action = plan_create ? Actions::Pulp::Repository::CreateInPlan : Actions::Pulp::Repository::Create
           sequence do
-            create_action = plan_pulp_action([pulp2_create_action, Pulp3::Orchestration::Repository::Create],
-                                        repository, SmartProxy.pulp_primary)
+            create_action = plan_action(Pulp3::Orchestration::Repository::Create,
+                                        repository, SmartProxy.pulp_primary, force_repo_create)
 
             return if create_action.error
 
@@ -25,8 +24,10 @@ module Actions
               if repository.product.redhat?
                 plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => repository.content_id)
               else
-                content_create = plan_action(Katello::Product::ContentCreate, root)
-                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => content_create.input[:content_id])
+                unless root.content
+                  content_create = plan_action(Katello::Product::ContentCreate, root)
+                  plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => content_create.input[:content_id])
+                end
               end
             end
 

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

@@ -10,7 +10,7 @@ module Actions
           repository.relative_path = repository.custom_repo_path
           repository.save!
           action_subject(repository)
-          plan_action(::Actions::Katello::Repository::Create, repository, false, true)
+          plan_action(::Actions::Katello::Repository::Create, repository)
         end
 
         def humanized_name

data/app/lib/actions/katello/repository_set/enable_repository.rb

@@ -15,7 +15,7 @@ module Actions
             fail ::Katello::Errors::ConflictException, _("The repository is already enabled")
           end
           repository = mapper.build_repository
-          plan_action(Repository::Create, repository, false, true)
+          plan_action(Repository::Create, repository, clone: false)
           action_subject(repository)
           plan_self
         end

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

@@ -22,6 +22,11 @@ module Actions
         end
 
         def invoke_external_task
+          if input[:options][:sync_task_output] &&
+              ::Katello::Pulp3::Task.publication_href(input[:options][:sync_task_output]).present?
+            return input[:options][:sync_task_output]
+          end
+
           repository = ::Katello::Repository.find(input[:repository_id])
           smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
           output[:response] = repository.backend_service(smart_proxy).with_mirror_adapter.create_publication

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

@@ -19,9 +19,10 @@ module Actions
           if options[:use_repository_version]
             repo.backend_service(smart_proxy).with_mirror_adapter.refresh_distributions(:use_repository_version => true)
           elsif tasks && tasks[:pulp_tasks] && tasks[:pulp_tasks].first
-            publication_href = tasks[:pulp_tasks].first[:created_resources].first
-            if publication_href
+            if (publication_href = ::Katello::Pulp3::Task.publication_href(tasks[:pulp_tasks]))
               repo.backend_service(smart_proxy).with_mirror_adapter.refresh_distributions(:publication => publication_href)
+            else
+              fail "Unable to refresh distribution for repo #{repository.id}, could not find a publication_href"
             end
           end
         end

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

@@ -5,7 +5,8 @@ module Actions
         include ::Actions::Helpers::SmartProxySyncHistoryHelper
         def plan(repository, smart_proxy, options = {})
           sequence do
-            plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :options => options)
+            sync_task = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :options => options)
+            options[:sync_task_output] = sync_task.output[:pulp_tasks]
             plan_action(GenerateMetadata, repository, smart_proxy, options)
           end
         end

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

@@ -1,13 +1,13 @@
 module Actions
   module Pulp3
     module ContentViewVersion
-      class DestroyExporter < Pulp3::Abstract
+      class DestroyExporter < Pulp3::AbstractAsyncTask
         input_format do
           param :smart_proxy_id, Integer
           param :exporter_data, Hash
         end
 
-        def run
+        def invoke_external_task
           ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy).destroy_exporter(input[:exporter_data][:pulp_href])
         end
       end

data/app/lib/actions/pulp3/orchestration/repository/create.rb

@@ -3,9 +3,9 @@ module Actions
     module Orchestration
       module Repository
         class Create < Pulp3::Abstract
-          def plan(repository, smart_proxy)
+          def plan(repository, smart_proxy, force = false)
             sequence do
-              create_action = plan_action(Actions::Pulp3::Repository::Create, repository, smart_proxy)
+              create_action = plan_action(Actions::Pulp3::Repository::Create, repository, smart_proxy, force)
               plan_action(Actions::Pulp3::Repository::SaveVersion, repository, repository_details: create_action.output[:response])
 
               if repository.content_view.default? || !smart_proxy.pulp_primary?

data/app/lib/actions/pulp3/orchestration/repository/generate_metadata.rb

@@ -6,6 +6,7 @@ module Actions
           def plan(repository, smart_proxy, options = {})
             options[:contents_changed] = (options && options.key?(:contents_changed)) ? options[:contents_changed] : true
             publication_content_type = !::Katello::RepositoryTypeManager.find(repository.content_type).pulp3_skip_publication
+
             sequence do
               if options[:source_repository] && publication_content_type
                 plan_self(source_repository_id: options[:source_repository].id, target_repository_id: repository.id, smart_proxy_id: smart_proxy.id)

data/app/lib/actions/pulp3/orchestration/repository/sync.rb

@@ -11,7 +11,7 @@ module Actions
 
               force_fetch_version = true if options[:optimize] == false
               version_output = plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks], :force_fetch_version => force_fetch_version).output
-              plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :contents_changed => version_output[:contents_changed])
+              plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :contents_changed => version_output[:contents_changed], :skip_publication_creation => version_output[:publication_provided])
               plan_self(:subaction_output => version_output)
             end
           end

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

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module Repository
       class Create < Pulp3::Abstract
-        def plan(repository, smart_proxy)
-          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
+        def plan(repository, smart_proxy, force = false)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :force => force)
         end
 
         def run
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).with_mirror_adapter.create
+          force = input[:force] || false
+          output[:response] = repo.backend_service(smart_proxy).with_mirror_adapter.create(force)
         end
       end
     end

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

@@ -5,14 +5,17 @@ module Actions
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
         def plan(repository, smart_proxy, options)
           sequence do
-            action = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :contents_changed => options[:contents_changed], :options => options)
+            action = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :contents_changed => options[:contents_changed],
+                               :skip_publication_creation => options[:skip_publication_creation])
             plan_action(SavePublication, repository, action.output, :contents_changed => options[:contents_changed])
           end
         end
 
         def invoke_external_task
-          repository = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repository.backend_service(smart_proxy).with_mirror_adapter.create_publication
+          unless input[:skip_publication_creation]
+            repository = ::Katello::Repository.find(input[:repository_id])
+            output[:response] = repository.backend_service(smart_proxy).with_mirror_adapter.create_publication
+          end
         end
       end
     end

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

@@ -10,6 +10,10 @@ module Actions
           repo = ::Katello::Repository.find(input[:repository_id])
           output[:response] = repo.backend_service(smart_proxy).create_remote
         end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module Actions
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
           backend = repo.backend_service(smart_proxy)
-          backend.update_remote if backend.remote_needs_updates?
+          backend.update_remote
         end
       end
     end

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

@@ -9,17 +9,24 @@ module Actions
 
         def run
           repo = ::Katello::Repository.find(input[:repository_id])
-
           if input[:force_fetch_version]
             version_href = fetch_version_href(repo)
           elsif input[:repository_details].present?
             version_href = input[:repository_details][:latest_version_href]
           elsif input[:tasks].present?
-            version_href = input[:tasks].last[:created_resources].first
+            version_href = ::Katello::Pulp3::Task.version_href(input[:tasks])
           else
             version_href = fetch_version_href(repo)
           end
 
+          output[:publication_provided] = false
+          if input[:tasks].present?
+            if (publication_href = ::Katello::Pulp3::Task.publication_href(input[:tasks]))
+              repo.update(:publication_href => publication_href)
+              output[:publication_provided] = true
+            end
+          end
+
           if version_href
             if repo.version_href != version_href || input[:force_fetch_version]
               output[:contents_changed] = true

data/app/lib/katello/agent/base_message.rb

@@ -12,10 +12,7 @@ module Katello
           replyto: reply_to,
           request: {
             args: [
-              units,
-              {
-                importkeys: true
-              }
+              units, options
             ],
             classname: "Content",
             cntr: [[], {}],
@@ -30,6 +27,12 @@ module Katello
         }
       end
 
+      def options # may be overridden by children
+        {
+          importkeys: true
+        }
+      end
+
       def to_s
         json.to_json
       end

data/app/lib/katello/agent/update_package_message.rb

@@ -10,7 +10,15 @@ module Katello
 
       protected
 
+      def options
+        ops = super
+        ops[:all] = true if @packages.blank?
+        ops
+      end
+
       def units
+        return [{ type_id: @content_type, unit_key: {}}] if @packages.blank?
+
         @packages.map do |package|
           {
             type_id: @content_type,

data/app/models/katello/candlepin/repository_mapper.rb

@@ -44,7 +44,7 @@ module Katello
       end
 
       def validate!
-        return if katello_content_type == Repository::OSTREE_TYPE
+        return if katello_content_type == Repository::OSTREE_TYPE || Setting[:content_disconnected]
         substitutor.validate_substitutions(content, substitutions)
       end
 

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

@@ -89,6 +89,10 @@ module Katello
         end
 
         def self.with_environment(environment, include_default = false)
+          (pulp2_proxies_with_environment(environment, include_default) + pulpcore_proxies_with_environment(environment)).try(:uniq)
+        end
+
+        def self.pulp2_proxies_with_environment(environment, include_default = false)
           features = [PULP_NODE_FEATURE]
           features << PULP_FEATURE if include_default
 
@@ -96,6 +100,11 @@ module Katello
               where(katello_capsule_lifecycle_environments: { lifecycle_environment_id: environment.id })
         end
 
+        def self.pulpcore_proxies_with_environment(environment)
+          unscoped.where(id: unscoped.select { |p| p.pulp_mirror? }.pluck(:id)).joins(:capsule_lifecycle_environments).
+              where(katello_capsule_lifecycle_environments: { lifecycle_environment_id: environment.id })
+        end
+
         def self.sync_needed?(environment)
           Setting[:foreman_proxy_content_auto_sync] && unscoped.with_environment(environment).any?
         end

data/app/models/katello/content_view_version.rb

@@ -231,7 +231,19 @@ module Katello
     end
 
     def available_packages
-      library_packages.where.not(:id => packages)
+      # The simple/obvious solution is:
+      #   library_packages.where.not(:id => packages)
+      # However, when the list of exclusions is large, the SQL "NOT IN" clause
+      # is extremely inefficient, and it is much better to use a
+      # "LEFT OUTER JOIN" with a subquery.
+      # ActiveRecord .joins() only supports subqueries by supplying raw SQL.  We
+      # use .to_sql to avoid hard-coding raw SQL for self.packages, although
+      # .to_sql may also be somewhat brittle.  For example, see:
+      # https://github.com/rails/rails/issues/18379
+      library_packages.joins(
+        "LEFT OUTER JOIN (#{packages.select('id').to_sql}) AS exclude_rpms ON " \
+        'katello_rpms.id = exclude_rpms.id'
+      ).where('exclude_rpms.id IS NULL')
     end
 
     def srpms
@@ -262,7 +274,19 @@ module Katello
     end
 
     def available_errata
-      library_errata.where.not(:id => errata)
+      # The simple/obvious solution is:
+      #   library_errata.where.not(:id => errata)
+      # However, when the list of exclusions is large, the SQL "NOT IN" clause
+      # is extremely inefficient, and it is much better to use a
+      # "LEFT OUTER JOIN" with a subquery.
+      # ActiveRecord .joins() only supports subqueries by supplying raw SQL.  We
+      # use .to_sql to avoid hard-coding raw SQL for self.errata, although
+      # .to_sql may also be somewhat brittle.  For example, see:
+      # https://github.com/rails/rails/issues/18379
+      library_errata.joins(
+        "LEFT OUTER JOIN (#{errata.select('id').to_sql}) AS exclude_errata ON " \
+        'katello_errata.id = exclude_errata.id'
+      ).where('exclude_errata.id IS NULL')
     end
 
     def file_units