katello 4.0.1.2 → 4.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 175f5091971a1a03e1ef6045897717e644600f46baa4255e76703b17f37a5bd6
-  data.tar.gz: e9f6e8a076b105e02e14bcfd4bfe61c4b50bd98b6fc96fd64e8be422e2c81696
+  metadata.gz: 77e02e169ae9d1f8c31a49999ac7f6fcc900e5a3c9338beb825d19e3ed8598a4
+  data.tar.gz: 7049ec270dcd1db4d3335d33f4665306178289888b7ba33e283f25d69a72768d
 SHA512:
-  metadata.gz: 4af5af4d5c32367976e4131d93e55d61c6802696e779615cd8bdf0f4cd1d9b5c1fccee39fdbe8d0c7148eda66ce1201800159537f57a29a1bcd686870f6173c6
-  data.tar.gz: e58234ec4c65a357a66c588ee1f2c226ebcfb0a4a843db3f36cda2263724974400601b16a577805a213d1b7dd84aaa46419dcb9f1960546f5b087f892b310e9c
+  metadata.gz: e4282384c1c10065f6d731af1e45a006cc4b5a294e1d906954fad02fd81db19faf772a3c8bcd81aca33dcf7bb2c779f740ea3a2155cefb84d9af041f6e55f2d6
+  data.tar.gz: 87a57f7437ebfdf7f567efbae8e24f60d1c5655aa18944085cc9ce141483b61b92637bf1f10999c5ea00d35fe16ec98f8e98fd0e9bb244bf294efe33ef84407c

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

@@ -39,7 +39,7 @@ module Actions
             end
 
             if smart_proxy.has_feature?(SmartProxy::PULP3_FEATURE)
-              plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy)
+              plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy)
               plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
             end
             plan_action(SyncCapsule, smart_proxy, refresh_options)

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

@@ -19,7 +19,8 @@ module Actions
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
-        def plan(old_version, environments, options = {}) # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def plan(old_version, environments, options = {})
           dep_solve = options.fetch(:resolve_dependencies, true)
           description = options.fetch(:description, '')
           content = options.fetch(:content, {})
@@ -72,8 +73,18 @@ 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],
+                          new_content_view_version,
+                          content,
+                          dep_solve)
+                      end
+                    end
+                  end
                 end
               end
 

data/app/lib/actions/katello/orphan_cleanup/remove_orphans.rb

@@ -1,13 +1,13 @@
 module Actions
   module Katello
     module OrphanCleanup
-      class RemoveOrphans < Pulp::Abstract
+      class RemoveOrphans < Actions::Base
         input_format do
           param :capsule_id
         end
         def plan(proxy)
           sequence do
-            plan_action(Actions::Pulp::Orchestration::OrphanCleanup::RemoveOrphans, proxy)
+            plan_action(Actions::Pulp::Orchestration::OrphanCleanup::RemoveOrphans, proxy) if (proxy.has_feature?(SmartProxy::PULP_FEATURE) || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE))
             if proxy.pulp3_enabled?
               plan_action(
                 Actions::Pulp3::Orchestration::OrphanCleanup::RemoveOrphans,

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

@@ -13,6 +13,7 @@ module Actions
         def run
           source_repo = ::Katello::Repository.find(input[:source_repo_id])
           target_repo = ::Katello::Repository.find(input[:target_repo_id])
+          target_repo_published = target_repo.backend_service(SmartProxy.pulp_primary).published?
 
           if source_repo.content_type == ::Katello::Repository::YUM_TYPE
             srpms_match = srpms_match?(source_repo, target_repo)
@@ -23,16 +24,14 @@ module Actions
             yum_metadata_files = yum_metadata_files_match?(source_repo, target_repo)
             checksum_match = (target_repo.saved_checksum_type == source_repo.saved_checksum_type)
 
-            published = target_repo.backend_service(SmartProxy.pulp_primary).published?
-
             output[:checksum_match] = checksum_match
-            output[:matching_content] = yum_metadata_files && srpms_match && rpms && errata && package_groups && distributions && published && checksum_match
+            output[:matching_content] = yum_metadata_files && srpms_match && rpms && errata && package_groups && distributions && target_repo_published && checksum_match
           end
 
           if source_repo.content_type == ::Katello::Repository::DEB_TYPE
             debs = debs_match?(source_repo, target_repo)
 
-            output[:matching_content] = debs && target_repo.published?
+            output[:matching_content] = debs && target_repo_published
           end
         end
 

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

@@ -2,16 +2,12 @@ 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
+        def plan(smart_proxy)
+          plan_self(smart_proxy_id: smart_proxy.id)
+        end
+
+        def run
+          ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy).refresh
         end
       end
     end

data/app/lib/actions/pulp3/orchestration/orphan_cleanup/remove_orphans.rb

@@ -2,7 +2,7 @@ module Actions
   module Pulp3
     module Orchestration
       module OrphanCleanup
-        class RemoveOrphans < Pulp::Abstract
+        class RemoveOrphans < Pulp3::Abstract
           def plan(proxy)
             if proxy.pulp3_enabled?
               sequence do

data/app/lib/katello/errors.rb

@@ -53,7 +53,7 @@ module Katello
 
     class PulpcoreMissingCapabilities < StandardError
       def message
-        _("A smart proxy seems to have been refreshed without pulpcore being running.  You may want to ")
+        _("A smart proxy seems to have been refreshed without pulpcore being running. Please refresh the smart proxy after ensuring that pulpcore services are running.")
       end
     end
 

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

@@ -0,0 +1,126 @@
+# Used exclusively by fix_hostgroup_facets.rake task
+module Katello
+  module Util
+    class HostgroupFacetsHelper
+      def initialize
+        @logger = Logger.new($stdout)
+      end
+
+      def interested_hostgroups
+        groups = ::Hostgroup.unscoped.where(
+                    id: Katello::Hostgroup::ContentFacet.
+                        where(content_source_id: nil,
+                              kickstart_repository_id: nil,
+                              content_view_id: nil,
+                              lifecycle_environment_id: nil).select(:hostgroup_id))
+        parents = groups.select { |group| group.parent.blank? }
+        children = groups.reject { |group| group.parent.blank? }
+        # we want the parents to get created before the children
+        # hence the order
+        parents + children
+      end
+
+      def pick_facet_values(hg)
+        # This call looks at the audit logs for a host group.
+        # Pries out information related to lce, ks, cv and content_source_id from the audit logs.
+        # The audit logs typically only contain updates.
+        # So if the user changed  just the content_view_id, then that is the only thing marked as audited_changes.
+        # Hence we need to go through all the audit logs until we have information on lce, ks, cv and cs.
+        # If there was only one audit log and that was during the creation of hostgroup
+        # the audited changes look like this
+        # ```ruby
+        # {
+        #  content_view_id: 10,
+        #  kickstart_repository_id: 1000
+        #  ......
+        # }
+        # ```
+        # However if you updated the hostgroup and set the kickstart_repository_id, or
+        # content_view_id then audited changes look like
+        # ```ruby
+        # {
+        #  content_view_id: [10, 11],
+        #  kickstart_repository_id: [1000, 1200]
+        #  ......
+        # }
+        # ```
+        # So the code says "if the attribute value is an array pick the last value else just keep the value as it is "
+
+        # Further along it is to be noted that `hostgroup.audits` returns the audits ordered by the version number in ascending order, so the latest audit will be `hostgroup.audits.last`
+
+        # We want to iterate though each audit from latest audit to start, and as soon as we find a  content_view_id key or kickstart_repository_id key or lifecycle environment_id key  or content_source_id key we want it to be set once.
+
+        # So if I had an audit history like
+        # ``` ruby
+        # {
+        #  content_view_id: 10,
+        #  kickstart_repository_id: 1000,
+        #  version:1
+        #  ......
+        # },
+        # {
+        #  content_view_id: [10, 11],
+        #  kickstart_repository_id: [1000, 1200],
+        #   version: 2
+        #  ......
+        # }
+        # ```
+
+        # The code would start at version 2, notice that cv_id and ks_repo were set there
+        # and keep them as the final.
+        # So when it goes to version 1 since cv_id and ks_repo are already set,
+        # it will ignore. It will finally
+        # return {content_view_id: 11, kickstart_repository_id: 1200}
+        facet_values = {}
+        hg.audits.reverse_each do |audit|
+          hg_changes = audit.audited_changes.slice("lifecycle_environment_id",
+                                                   "kickstart_repository_id",
+                                                   "content_view_id",
+                                                   "content_source_id")
+          facet_values = hg_changes.merge(facet_values)
+        end
+
+        values = facet_values.map do |k, v|
+          v = v[-1] if v.is_a? Array
+          [k, v]
+        end
+        values.to_h.with_indifferent_access
+      end
+
+      def main
+        bad_hgs = []
+        good_hgs = []
+
+        groups = interested_hostgroups.each do |hg|
+          facet = hg.content_facet
+          values = pick_facet_values(hg)
+          if !values.empty? && facet.update(values)
+            good_hgs << { hostgroup: hg, facet_values: values }
+          else
+            bad_hgs << { hostgroup: hg, facet_values: values }
+            facet.save(validate: false)
+          end
+        end
+
+        unless bad_hgs.empty?
+          @logger.warn "Some of the hostgroups reported a validation error. "\
+                        "The hostgroups have been updated. "\
+                        "Check via the Web UI."
+
+          bad_hgs.each do |bad_group|
+            @logger.warn "Hostgroup #{bad_group[:hostgroup]}"
+            @logger.warn "Facet Values #{bad_group[:facet_values]}"
+          end
+        end
+        unless good_hgs.empty?
+          @logger.info "Following hostgroups were succesfully updated."
+          good_hgs.each do |good_group|
+            @logger.info "Hostgroup #{good_group[:hostgroup]}"
+            @logger.info "Facet Values #{good_group[:facet_values]}"
+          end
+        end
+        @logger.info("#{groups.count} Hostgroup(s) were updated.")
+      end
+    end
+  end
+end

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

@@ -107,7 +107,9 @@ module Katello
         return true unless operatingsystem
 
         if operatingsystem.respond_to? :kickstart_repos
-          return operatingsystem.kickstart_repos(self).any? { |repo| repo[:id] == (content_facet&.kickstart_repository_id || content_facet&.kickstart_repository&.id) }
+          operatingsystem.kickstart_repos(self, content_facet: content_facet).any? do |repo|
+            repo[:id] == (content_facet&.kickstart_repository_id || content_facet&.kickstart_repository&.id)
+          end
         end
       end
 

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

@@ -10,8 +10,15 @@ module Katello
           minor ||= '' # treat minor versions as empty string to not confuse with nil
           os = ::Redhat.where(:name => os_name, :major => major, :minor => minor).try(:first)
           return os if os
-          description = "#{os_name}-#{repo.distribution_version}"
-          create_os = lambda { ::Redhat.create!(:name => os_name, :major => major, :minor => minor, :description => description) }
+
+          if ::Redhat.where(:title => "#{os_name} #{repo.distribution_version}").present?
+            description = "#{os_name} #{repo.distribution_version} #{SecureRandom.uuid}"
+            create_os = lambda do
+              ::Redhat.create!(:name => os_name, :major => major, :minor => minor, :description => description)
+            end
+          else
+            create_os = lambda { ::Redhat.create!(:name => os_name, :major => major, :minor => minor) }
+          end
 
           begin
             create_os.call
@@ -42,10 +49,11 @@ module Katello
         end
       end
 
-      def kickstart_repos(host)
-        distros = distribution_repositories(host).where(distribution_bootable: true)
-        if distros && host&.content_facet&.content_source
-          distros.map { |distro| distro.to_hash(host.content_facet.content_source) }
+      def kickstart_repos(host, content_facet: nil)
+        distros = distribution_repositories(host, content_facet: content_facet).where(distribution_bootable: true)
+        content_facet ||= host.content_facet
+        if distros && content_facet&.content_source
+          distros.map { |distro| distro.to_hash(content_facet.content_source) }
         else
           []
         end
@@ -62,10 +70,10 @@ module Katello
         end
       end
 
-      def distribution_repositories(host)
-        content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
-        lifecycle_environment = host.try(:content_facet).try(:lifecycle_environment) || host.try(:lifecycle_environment)
-
+      def distribution_repositories(host, content_facet: nil)
+        content_facet ||= host.content_facet
+        content_view = content_facet.try(:content_view) || host.try(:content_view)
+        lifecycle_environment = content_facet.try(:lifecycle_environment) || host.try(:lifecycle_environment)
         if content_view && lifecycle_environment && host.os && host.architecture
           Katello::Repository.in_environment(lifecycle_environment).in_content_views([content_view]).
               where(:distribution_arch => host.architecture.name).

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

@@ -90,6 +90,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
 
@@ -97,6 +101,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/glue/pulp/repo.rb

@@ -74,11 +74,6 @@ module Katello
         pulp_repo_facts['content_unit_counts']['srpm']
       end
 
-      def uri
-        uri = URI.parse(SETTINGS[:katello][:pulp][:url])
-        "https://#{uri.host}/pulp/content/#{relative_path}"
-      end
-
       def to_hash
         pulp_repo_facts.merge(as_json).merge(:sync_state => sync_state)
       end
@@ -364,19 +359,5 @@ module Katello
         end
       end
     end
-
-    def full_path(smart_proxy = nil, force_http = false)
-      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : SETTINGS[:katello][:pulp][:url])
-      scheme = force_http ? 'http' : 'https'
-      if docker?
-        "#{pulp_uri.host.downcase}/#{container_repository_name}"
-      elsif ostree?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/web/#{relative_path}"
-      elsif ansible_collection?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp_ansible/galaxy/#{relative_path}/api"
-      else
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/#{relative_path}/"
-      end
-    end
   end
 end

data/app/models/katello/ping.rb

@@ -5,17 +5,10 @@ module Katello
     PACKAGES = %w(katello candlepin pulp qpid foreman tfm hammer).freeze
 
     class << self
-      def pulpcore_enabled # for downstream 6.9, remove in 6.10
-        SETTINGS[:katello][:use_pulp_2_for_content_type].nil? || (!SETTINGS[:katello][:use_pulp_2_for_content_type][:yum] &&
-        !SETTINGS[:katello][:use_pulp_2_for_content_type][:docker] &&
-        !SETTINGS[:katello][:use_pulp_2_for_content_type][:file]) ||
-        system('systemctl is-enabled pulpcore-api.service &>/dev/null')
-      end
-
       def services(capsule_id = nil)
         proxy = fetch_proxy(capsule_id)
-        services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events, :katello_agent]
-        services += [:pulp3] if proxy&.pulp3_enabled? && pulpcore_enabled
+        services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events]
+        services += [:pulp3] if proxy&.pulp3_enabled?
         if proxy.nil? || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE) || proxy.has_feature?(SmartProxy::PULP_FEATURE)
           services += [:pulp, :pulp_auth]
         end

data/app/models/katello/repository.rb

@@ -395,6 +395,20 @@ module Katello
       all_instances
     end
 
+    def full_path(smart_proxy = nil, force_http = false)
+      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : ::SmartProxy.pulp_primary.url)
+      scheme = force_http ? 'http' : 'https'
+      if docker?
+        "#{pulp_uri.host.downcase}/#{container_repository_name}"
+      elsif ostree?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/web/#{relative_path}"
+      elsif ansible_collection?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp_ansible/galaxy/#{relative_path}/api"
+      else
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/#{relative_path}/"
+      end
+    end
+
     def to_hash(content_source = nil, force_http = false)
       {id: id, name: label, url: full_path(content_source, force_http)}
     end

data/app/services/cert/certs.rb

@@ -8,6 +8,10 @@ module Cert
       File.open(Setting[:ssl_ca_file], 'r').read
     end
 
+    def self.candlepin_client_ca_cert
+      File.read(SETTINGS[:katello][:candlepin][:ca_cert_file])
+    end
+
     def self.ssl_client_cert
       @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.open(ssl_client_cert_filename, 'r').read)
     end

data/app/services/katello/pulp3/api/content_guard.rb

@@ -4,6 +4,10 @@ module Katello
   module Pulp3
     module Api
       class ContentGuard < Core
+        def default_name
+          'RHSMCertGuard'
+        end
+
         def self.client_module
           PulpCertguardClient
         end
@@ -20,19 +24,49 @@ module Katello
           PulpCertguardClient::ContentguardsRhsmApi.new(api_client)
         end
 
-        def create(name = "RHSMCertGuard", ca_certificate = Cert::Certs.ca_cert)
-          data = PulpCertguardClient::CertguardRHSMCertGuard.new(name: name, ca_certificate: ca_certificate)
+        def ca_cert
+          Cert::Certs.candlepin_client_ca_cert
+        end
+
+        def refresh
+          found = list(name: default_name).results.first
+          if found && found.ca_certificate != ca_cert
+            partial_update(found.pulp_href)
+          else
+            found = create
+          end
+          persist_if_needed(found.pulp_href)
+        end
+
+        def persist_if_needed(href)
+          return if self.smart_proxy.pulp_mirror?
+          Katello::Util::Support.active_record_retry do
+            found = Katello::Pulp3::ContentGuard.find_by(:name => default_name)
+            if found
+              found.update(pulp_href: href)
+            else
+              Katello::Pulp3::ContentGuard.create(name: default_name, pulp_href: href)
+            end
+          end
+        end
+
+        def create(name = default_name)
+          data = PulpCertguardClient::CertguardRHSMCertGuard.new(name: name, ca_certificate: ca_cert)
           rhsm_api_client.create(data)
         rescue self.class.api_exception_class => e
-          raise e unless list&.results&.first
+          if (found = list&.results&.first) #check for possible race condition
+            found
+          else
+            raise e
+          end
         end
 
         def list(options = {})
           rhsm_api_client.list options
         end
 
-        def partial_update(href, ca_certificate = Cert::Certs.ca_cert)
-          data = PulpCertguardClient::CertguardRHSMCertGuard.new(ca_certificate: ca_certificate)
+        def partial_update(href)
+          data = PulpCertguardClient::CertguardRHSMCertGuard.new(ca_certificate: ca_cert)
           rhsm_api_client.partial_update(href, data)
         end