katello 3.16.0.rc1 → 3.16.0.rc3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d0debf5f9051e065167937b3354840869f66883b76f317b5539ff1d0ac6d6b
-  data.tar.gz: ed132fe6776f18ab484f6a8e23523e4386446de37c6366b92237ea015108c74b
+  metadata.gz: 6c111ad081f2588aaf6e770186fc98a2945887a06e465cdce62cc7fc20d56205
+  data.tar.gz: bb1a4f8f3872e632bf36deb2db63a92753f5f4eaab3cea97bb47d5809d24e9ec
 SHA512:
-  metadata.gz: 2eabc43ae7c6d400b882c119164d81bbf1a16c1e2c2c0e24846d425dcae98cb7fc42d3131cc976997f0d1cc1451350ea01ee0ee848e6349778362fcb87efb781
-  data.tar.gz: 2e9726cf094952556a6d02f05f446949cf54fcfb9fe5f2c971a804a9107170a9ae057f441808d4fda73c4c4f66f2f45fd2a1cf93345f406177acc7684b35028a
+  metadata.gz: 30b8f98b25c3a1f04d8796a9e060868e306f802dc50fc140f8d528eec3afe4c2c564d8f20858edb753c9ba75a6c3e56d26636c2b8bdbb5e6363e07d2af1d81a6
+  data.tar.gz: af95e39c10ea7d9ed8805db3dc18be1a58e90a2e24d18fbf9e99ff1eb710abb657737b6a5094c693a2cee42f2bcdc798a9de6395e250645059f3134c89d913c7

data/app/controllers/katello/remote_execution_controller.rb

@@ -43,7 +43,7 @@ module Katello
       end
 
       def errata_inputs
-        if params[:install_all]
+        if ::Foreman::Cast.to_bool(params[:install_all])
           Erratum.installable_for_hosts(hosts).pluck(:errata_id).join(',')
         else
           params[:name]

data/app/lib/actions/katello/applicability/hosts/{generate.rb → bulk_generate.rb}

@@ -2,17 +2,26 @@ module Actions
   module Katello
     module Applicability
       module Hosts
-        class Generate < Actions::EntryAction
+        class BulkGenerate < Actions::EntryAction
           input_format do
             param :host_ids, Array
           end
 
           def run
             input[:host_ids].each do |host_id|
-              ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, host_id)
+              content_facet = ::Host.find(host_id).content_facet
+              content_facet.calculate_and_import_applicability
             end
           end
 
+          def queue
+            ::Katello::HOST_TASKS_QUEUE
+          end
+
+          def resource_locks
+            :link
+          end
+
           def humanized_name
             _("Bulk generate applicability for hosts")
           end

data/app/lib/actions/katello/applicability/repository/regenerate.rb

@@ -11,9 +11,14 @@ module Actions
           end
 
           def run
-            ::Katello::Repository.find(input[:repo_id]).content_facets.each do |facet|
-              ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, facet.host.id)
+            host_ids = ::Katello::Repository.find(input[:repo_id]).hosts_with_applicability.pluck(:id)
+            return if host_ids.empty?
+
+            host_ids.each do |host_id|
+              ::Katello::ApplicableHostQueue.push_host(host_id)
             end
+
+            ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, 0)
           end
 
           def humanized_name

data/app/lib/actions/katello/host/generate_applicability.rb

@@ -8,7 +8,7 @@ module Actions
 
         def plan(hosts, use_queue = true)
           if SETTINGS[:katello][:katello_applicability]
-            plan_action(::Actions::Katello::Applicability::Hosts::Generate, host_ids: hosts.pluck(:id))
+            plan_self(:host_ids => hosts.map(&:id))
           else
             uuids = hosts.map { |host| host.content_facet.try(:uuid) }.compact
             unless uuids.empty?
@@ -19,7 +19,12 @@ module Actions
         end
 
         def finalize
-          unless SETTINGS[:katello][:katello_applicability]
+          if SETTINGS[:katello][:katello_applicability]
+            input[:host_ids].each do |host_id|
+              ::Katello::ApplicableHostQueue.push_host(host_id)
+            end
+            ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, 0)
+          else
             input[:host_ids].each do |host_id|
               if input[:use_queue]
                 ::Katello::EventQueue.push_event(::Katello::Events::ImportHostApplicability::EVENT_TYPE, host_id)

data/app/lib/actions/katello/host/upload_profiles.rb

@@ -33,16 +33,51 @@ module Actions
           Dynflow::Action::Rescue::Skip
         end
 
+        def self.upload_modules_to_pulp(available_streams, host)
+          query_name_streams = available_streams.map do |profile|
+            ::Katello::ModuleStream.where(profile.slice(:name, :stream))
+          end
+
+          updated_profiles = []
+          unless query_name_streams.empty?
+            query_name_streams = query_name_streams.inject(&:or)
+
+            bound_library_instances = host.content_facet.bound_repositories.map(&:library_instance_or_self)
+            query = ::Katello::ModuleStream.in_repositories(bound_library_instances).
+                                            select(:name, :stream, :version, :context, :arch).
+                                              merge(query_name_streams)
+
+            updated_profiles = query.map do |module_stream|
+              module_stream.slice(:name, :stream, :version, :context, :arch)
+            end
+          end
+
+          # We also need to pass module streams that are not found in the ModuleStream table
+          # but are present on the content host
+          unassociated_profiles = available_streams.select do |profile|
+            updated_profiles.none? { |p| p[:name] == profile[:name] && p[:stream] == profile[:stream] }
+          end
+
+          module_stream_profile = updated_profiles + unassociated_profiles
+
+          unless module_stream_profile.empty?
+            begin
+              ::Katello::Pulp::Consumer.new(host.content_facet.uuid).
+                upload_module_stream_profile(module_stream_profile)
+            rescue RestClient::ResourceNotFound
+              Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % host.id)
+            end
+          end
+        end
+
         def import_module_streams(payload, host)
           enabled_payload = payload.map do |profile|
-            profile.slice("name", "stream", "version", "context", "arch") if profile["status"] == "enabled"
+            profile.slice("name", "stream", "version", "context", "arch").with_indifferent_access if profile["status"] == "enabled"
           end
           enabled_payload.compact!
 
-          ::Katello::Pulp::Consumer.new(host.content_facet.uuid).upload_module_stream_profile(enabled_payload)
+          UploadProfiles.upload_modules_to_pulp(enabled_payload, host)
           host.import_module_streams(payload)
-        rescue RestClient::ResourceNotFound
-          Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % input[:host_id])
         end
 
         def import_deb_package_profile(host, profile)
@@ -69,6 +104,7 @@ module Actions
             payload = profiles.dig("deb_package_profile", "deb_packages") || []
             import_deb_package_profile(host, payload)
           else
+            module_streams = []
             profiles.each do |profile|
               payload = profile["profile"]
               case profile["content_type"]
@@ -79,9 +115,13 @@ module Actions
               when "enabled_repos"
                 host.import_enabled_repositories(payload)
               else
-                import_module_streams(payload, host)
+                module_streams << payload
               end
             end
+
+            module_streams.each do |module_stream_payload|
+              import_module_streams(module_stream_payload, host)
+            end
           end
         end
       end

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

@@ -26,8 +26,7 @@ module Actions
           incremental = options.fetch(:incremental, false)
           validate_contents = options.fetch(:validate_contents, false)
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && repo.yum?)
-          # TODO: Remove the check for Pulp 3 once Pulp 3 errata is working fully
-          generate_applicability = repo.yum? && !SmartProxy.pulp_master.pulp3_support?(repo)
+          generate_applicability = repo.yum?
 
           fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?

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

@@ -10,6 +10,8 @@ module Actions
           action_subject root.library_instance
 
           repo_params[:url] = nil if repo_params[:url] == ''
+          update_cv_cert_protected = (repo_params[:unprotected] != repository.unprotected)
+
           root.update!(repo_params)
 
           if root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
@@ -44,15 +46,24 @@ module Actions
                               ::Actions::Pulp3::Orchestration::Repository::Update],
                              repository,
                              SmartProxy.pulp_master)
-            plan_self(:repository_id => root.library_instance.id)
+            plan_self(:repository_id => root.library_instance.id, :update_cv_cert_protected => update_cv_cert_protected)
           end
         end
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
+          output[:repository_id] = input[:repository_id]
+          output[:update_cv_cert_protected] = input[:update_cv_cert_protected]
           ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
         end
 
+        def finalize
+          repository = ::Katello::Repository.find(output[:repository_id])
+          if output[:update_cv_cert_protected]
+            ForemanTasks.async_task(::Actions::Katello::Repository::UpdateCVRepoCertGuard, repository, SmartProxy.pulp_master)
+          end
+        end
+
         private
 
         def update_content?(repository)

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

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module Repository
+      class UpdateCVRepoCertGuard < Actions::Base
+        include Actions::Katello::PulpSelector
+
+        def plan(repository, smart_proxy)
+          plan_optional_pulp_action([::Actions::Pulp3::Repository::UpdateCVRepositoryCertGuard], repository, smart_proxy)
+        end
+
+        def humanized_name
+          _("Updating repository authentication configuration")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/ContentGuard/refresh.rb

@@ -0,0 +1,19 @@
+module Actions
+  module Pulp3
+    module ContentGuard
+      class Refresh < Pulp3::Abstract
+        def plan(smart_proxy, options = {})
+          return if (::Katello::Pulp3::ContentGuard.count > 0 || options.try(:[], :update))
+          content_guard_api = ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
+          if options.try(:[], :update)
+            content_guard_href = ::Katello::Pulp3::ContentGuard.first.href
+            content_guard_api.partial_update content_guard_href
+          else
+            content_guard_api.create
+            ::Katello::Pulp3::ContentGuard.import(smart_proxy)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,25 +13,23 @@ module Actions
             if filter_ids.present? || rpm_filenames.present? || source_repositories.length > 1
               sequence do
                 if filter_ids.present? || rpm_filenames.present?
-                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent,
-                                            source_repositories.first, smart_proxy, target_repo,
+                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, source_repositories.first, smart_proxy, target_repo,
                                             filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                             rpm_filenames: rpm_filenames)
-
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
+                              repository_details: { latest_version_href: copy_action.output[:latest_version_href] }, tasks: copy_action.output[:pulp_tasks])
                 else
                   #if we are not filtering, copy the version to the cv repository, and the units for each additional repo
                   action = plan_action(Actions::Pulp3::Repository::CopyVersion, source_repositories.first, smart_proxy, target_repo)
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
+                              repository_details: { latest_version_href: action.output[:latest_version_output] }, tasks: action.output[:pulp_tasks])
                   copy_actions = []
                   #since we're creating a new version from the first repo, start copying at the 2nd
                   source_repositories[1..-1].each do |source_repo|
-                    copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent,
-                                                source_repo, smart_proxy, target_repo,
+                    copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent, source_repo, smart_proxy, target_repo,
                                                 filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                                 rpm_filenames: rpm_filenames)
                   end
-
                   plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_actions.last.output[:pulp_tasks])
                 end
               end

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

@@ -12,7 +12,7 @@ module Actions
               elsif publication_content_type
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
-
+              plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
               plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if repository.environment
             end
           end

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

@@ -11,6 +11,7 @@ module Actions
         def invoke_external_task
           source = ::Katello::Repository.find(input[:source_repository_id])
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
+          output[:latest_version_href] = target.backend_service(smart_proxy).read.latest_version_href
           output[:pulp_tasks] = target.backend_service(smart_proxy).copy_content_for_source(source, input)
         end
       end

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

@@ -9,6 +9,7 @@ module Actions
           sequence do
             options = {:repository_id => repository.id, :smart_proxy_id => smart_proxy.id}
             options[:contents_changed] if options.key?(:contents_changed)
+            plan_action(::Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
             action = plan_self(options)
             plan_action(SaveDistributionReferences, repository, smart_proxy,
                         action.output, :contents_changed => options[:contents_changed])

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

@@ -12,9 +12,11 @@ module Actions
           if input[:tasks] && input[:tasks][:pulp_tasks] && input[:tasks][:pulp_tasks].first
             distribution_hrefs = input[:tasks][:pulp_tasks].map { |task| task[:created_resources].first }
             distribution_hrefs.compact!
+            repo = ::Katello::Repository.find(input[:repository_id])
             if distribution_hrefs.any?
-              repo = ::Katello::Repository.find(input[:repository_id])
               repo.backend_service(smart_proxy).save_distribution_references(distribution_hrefs)
+            else
+              repo.backend_service(smart_proxy).update_distribution
             end
           end
         end

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

@@ -11,7 +11,9 @@ module Actions
 
           if input[:tasks]
             version_href = input[:tasks].last[:created_resources].first
-          elsif input[:repository_details]
+          end
+
+          if !version_href && input[:repository_details]
             version_href = input[:repository_details][:latest_version_href]
           end
 

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

@@ -0,0 +1,15 @@
+module Actions
+  module Pulp3
+    module Repository
+      class UpdateCVRepositoryCertGuard < Pulp3::Abstract
+        def plan(repository, _smart_proxy)
+          root = repository.root
+          cv_repositories = root.repositories - [root.library_instance]
+          cv_repositories.each do |repo|
+            plan_action(::Actions::Pulp3::Repository::RefreshDistribution, repo, SmartProxy.pulp_master)
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -8,7 +8,8 @@ module Katello
           super + [:errata, :host_subscriptions, :host_applicable_errata_ids, :host_applicable_errata_filtered,
                    :host_latest_applicable_rpm_version, :load_pools, :load_errata_applications, :host_content_facet,
                    :host_sla, :host_products, :sub_name, :sub_sku, :registered_through, :last_checkin, :host_collections,
-                   :host_subscriptions_names, :host_subscriptions, :host_products_names, :host_collections_names]
+                   :host_subscriptions_names, :host_subscriptions, :host_products_names, :host_collections_names,
+                   :host_redhat_subscription_names, :registered_at]
         end
       end
 
@@ -28,6 +29,10 @@ module Katello
         host.subscriptions.map(&:name)
       end
 
+      def host_redhat_subscription_names(host)
+        host.subscriptions.redhat.pluck(:name)
+      end
+
       def host_content_facet(host)
         host.content_facet
       end
@@ -71,6 +76,10 @@ module Katello
         host_subscription_facet(host)&.registered_through
       end
 
+      def registered_at(host)
+        host_subscription_facet(host)&.registered_at
+      end
+
       def host_applicable_errata_ids(host)
         host.applicable_errata.map(&:errata_id)
       end

data/app/lib/katello/logging.rb

@@ -0,0 +1,14 @@
+module Katello
+  module Logging
+    def self.time(message, data: {}, logger: Rails.logger, level: :info)
+      start = Time.now
+
+      yield
+
+      data[:duration] = ((Time.now - start) * 1000).truncate(2)
+      data_string = data.map { |k, v| "#{k}=#{v}" }.join(' ')
+
+      logger.send(level, "#{message} #{data_string}")
+    end
+  end
+end

data/app/lib/katello/util/errata.rb

@@ -45,6 +45,19 @@ module Katello
           return errata_list
         end
       end
+
+      def filter_errata_by_pulp_href(errata, package_pulp_hrefs)
+        return [] if package_pulp_hrefs.empty?
+        rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
+        rpm_filenames = rpms.map { |rpm| File.basename(rpm.filename) }
+        matching_errata = []
+        errata.each do |erratum|
+          if erratum.packages.any? && (erratum.packages.pluck(:filename) - rpm_filenames).empty?
+            matching_errata << erratum
+          end
+        end
+        matching_errata
+      end
     end
   end
 end

data/app/lib/katello/util/pulpcore_content_filters.rb

@@ -0,0 +1,32 @@
+module Katello
+  module Util
+    module PulpcoreContentFilters
+      def filter_distribution_trees_by_pulp_hrefs(distributiontree_results, _content_pulp_hrefs)
+        distributiontree_results.collect { |result| result.pulp_href }.flatten.uniq
+      end
+
+      def filter_package_groups_by_pulp_href(package_groups, package_pulp_hrefs)
+        rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
+        package_groups.reject do |package_group|
+          (package_group.package_names & rpms.pluck(:name)).empty?
+        end
+      end
+
+      def filter_package_environments_by_pulp_hrefs(packageenvironment_results, package_pulp_hrefs)
+        matching_package_env_groups = []
+
+        packageenvironment_results.each do |result|
+          if (result.packagegroups & package_pulp_hrefs).any?
+            matching_package_env_groups << result.pulp_href
+          end
+        end
+
+        matching_package_env_groups.flatten.uniq
+      end
+
+      def filter_metadatafiles_by_pulp_hrefs(metadatafiles_results, _package_pulp_hrefs)
+        metadatafiles_results.collect { |result| result.pulp_href }.flatten.uniq
+      end
+    end
+  end
+end