katello 4.18.1 → 4.19.0.rc2

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

@@ -9,35 +9,56 @@ 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 = ::Katello::Pulp3::Task.version_href(input[:tasks])
-          else
-            version_href = fetch_version_href(repo)
-          end
+          version_href = determine_version_href(repo)
+
+          save_publication_if_present(repo)
+          save_version_if_changed(repo, version_href)
+        end
+
+        def determine_version_href(repo)
+          return fetch_version_href(repo) if input[:force_fetch_version]
+          return input[:repository_details][:latest_version_href] if input[:repository_details].present?
+          return ::Katello::Pulp3::Task.version_href(input[:tasks]) if input[:tasks].present?
+          fetch_version_href(repo)
+        end
 
+        def save_publication_if_present(repo)
           output[:publication_provided] = false
-          if input[:tasks].present? && (publication_href = ::Katello::Pulp3::Task.publication_href(input[:tasks]))
-            repo.update(:publication_href => publication_href)
-            output[:publication_provided] = true
-          end
+          return if input[:tasks].blank?
+
+          publication_href = ::Katello::Pulp3::Task.publication_href(input[:tasks])
+          return unless publication_href
 
+          repo_backend_service = repo.backend_service(SmartProxy.pulp_primary)
+          publication = repo_backend_service.api.publications_api.read(publication_href, {fields: 'prn'})
+          repo.update(:publication_href => publication_href, :publication_prn => publication.prn)
+          output[:publication_provided] = true
+        end
+
+        def save_version_if_changed(repo, version_href)
           if version_href
-            if repo.version_href != version_href || input[:force_fetch_version]
-              output[:contents_changed] = true
-              repo.update(:last_contents_changed => DateTime.now)
-              repo.update(:version_href => version_href)
-            end
+            update_version_if_changed(repo, version_href)
+          else
+            check_publication_version_match(repo)
+          end
+        end
+
+        def update_version_if_changed(repo, version_href)
+          return unless repo.version_href != version_href || input[:force_fetch_version]
+
+          output[:contents_changed] = true
+          repo.update(:last_contents_changed => DateTime.now)
+          repo_backend_service = repo.backend_service(SmartProxy.pulp_primary)
+          version = repo_backend_service.api.repository_versions_api.read(version_href, {fields: 'prn'})
+          repo.update(:version_href => version_href, :version_prn => version.prn)
+        end
+
+        def check_publication_version_match(repo)
+          # get publication and check if repo-version and publication match. Otherwise, contents_changed: false
+          if !repo.repository_type.pulp3_skip_publication && fetch_current_published_version_href(repo) != repo.version_href
+            output[:contents_changed] = true
           else
-            # get publication and check if repo-version and publication match. Otherwise, contents_changed: false
-            if !repo.repository_type.pulp3_skip_publication && fetch_current_published_version_href(repo) != repo.version_href
-              output[:contents_changed] = true
-            else
-              output[:contents_changed] = false
-            end
+            output[:contents_changed] = false
           end
         end
 

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

@@ -37,7 +37,8 @@ module Actions
             end
 
             unless new_version_href == repo.version_href
-              repo.update(version_href: new_version_href)
+              version = repo_backend_service.api.repository_versions_api.read(new_version_href, {fields: 'prn'})
+              repo.update(version_href: new_version_href, version_prn: version.prn)
               repo.index_content
               output[:contents_changed] = true
               output[:updated_repositories] << repo.id

data/app/lib/katello/resources/candlepin/activation_key.rb

@@ -10,11 +10,10 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access akeys
           end
 
-          def create(name, owner_key, auto_attach, service_level, release_version, purpose_role, purpose_usage)
+          def create(name, owner_key, service_level, release_version, purpose_role, purpose_usage)
             url = "/candlepin/owners/#{owner_key}/activation_keys"
             params = {
               name: name,
-              autoAttach: auto_attach,
               serviceLevel: service_level,
               releaseVer: release_version,
               role: purpose_role,
@@ -24,8 +23,8 @@ module Katello
             JSON.parse(response.body).with_indifferent_access
           end
 
-          def update(id, release_version, service_level, auto_attach, purpose_role, purpose_usage)
-            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :autoAttach => auto_attach, :role => purpose_role, :usage => purpose_usage }.delete_if { |_k, v| v.nil? }
+          def update(id, release_version, service_level, purpose_role, purpose_usage)
+            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :role => purpose_role, :usage => purpose_usage }.delete_if { |_k, v| v.nil? }
             JSON.parse(self.put(path(id), attrs.to_json, self.default_headers).body).with_indifferent_access
           end
 

data/app/lib/katello/resources/candlepin/upstream_job.rb

@@ -5,13 +5,14 @@ module Katello
         class << self
           NOT_FINISHED_STATES = %w(CREATED WAITING PENDING RUNNING).freeze unless defined? NOT_FINISHED_STATES
           API_URL = 'https://subscription.rhsm.redhat.com/subscription'.freeze
+          SUBSCRIPTION_PATH = '/subscription'.freeze
 
           def not_finished?(job)
             NOT_FINISHED_STATES.include?(job[:state])
           end
 
           def get(id, upstream)
-            url = ENV['REDHAT_RHSM_API_URL'] || API_URL
+            url = subscription_path(ENV['REDHAT_RHSM_API_URL']) || subscription_path(upstream['apiUrl']) || API_URL
             response = Resources::Candlepin::UpstreamConsumer.start_upstream_export("#{url}#{path(id)}", upstream['idCert']['cert'],
               upstream['idCert']['key'], nil)
             job = JSON.parse(response)
@@ -21,6 +22,13 @@ module Katello
           def path(id = nil)
             "/jobs/#{id}"
           end
+
+          def subscription_path(upstream_api_url)
+            return if upstream_api_url.blank?
+            uri = URI.parse(upstream_api_url) # https://subscription.rhsm.redhat.com/subscription/consumers/
+            uri.path = SUBSCRIPTION_PATH # https://subscription.rhsm.redhat.com/subscription
+            uri.to_s
+          end
         end
       end
     end

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

@@ -88,6 +88,10 @@ module Katello
         class << self
           delegate :[], to: :json_resource
 
+          def default_headers(uuid = nil)
+            super(uuid).except('cp-user', 'cp-consumer')
+          end
+
           def resource(options = {}, url: self.site + self.path, client_cert: self.client_cert, client_key: self.client_key, ca_file: nil)
             cert_store = OpenSSL::X509::Store.new
             cert_store.add_file(ca_file) if ca_file

data/app/models/katello/authorization/repository.rb

@@ -39,14 +39,27 @@ module Katello
 
       def readable_docker_catalog(host = nil)
         if host
-          repo_ids = nil
+          repo_ids = []
           if host&.content_view_environments&.any?
             repo_ids = host.content_view_environments.flat_map do |cve|
-              cve&.content_view_version&.repositories&.where(environment_id: cve.environment)&.non_archived&.docker_type&.pluck(:id)
+              cve&.content_view_version&.repositories&.where(environment_id: cve.environment)&.pluck(:id)
             end
+            repo_ids = repo_ids.compact.uniq
+          end
+
+          base_scope = Katello::Repository.non_archived.docker_type
+          host_repos = base_scope.where(id: repo_ids)
+
+          table_name = Repository.table_name
+          in_unauth_environments = Repository.joins(:environment)
+                                             .where("#{Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true)
+                                             .select(:id)
+
+          if in_unauth_environments.exists?
+            return host_repos.or(base_scope.joins(:root).where("#{table_name}.id in (?)", in_unauth_environments))
+          else
+            return host_repos
           end
-          repos = Katello::Repository.where(id: repo_ids)
-          return repos
         end
         readable_docker_catalog_as(User.current)
       end

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

@@ -21,7 +21,6 @@ module Katello
         scoped_search on: :status, relation: :rhel_lifecycle_status_object, rename: :rhel_lifecycle_status, complete_value: rhel_lifecycle_status_map
 
         scoped_search :on => :release_version, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
-        scoped_search :on => :autoheal, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :service_level, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :last_checkin, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :registered_through, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
@@ -45,8 +44,6 @@ module Katello
         content_facet.cves_changed = false if content_facet
         content_facet&.save!
 
-        auto_attach_enabled_via_checkin = consumer_params.try(:[], 'autoheal')
-
         if subscription_facet
           consumer_params ||= subscription_facet.consumer_attributes
 
@@ -59,10 +56,6 @@ module Katello
           end
           ::Katello::Resources::Candlepin::Consumer.update(subscription_facet.uuid, consumer_params)
 
-          if auto_attach_enabled_via_checkin
-            ::Katello::Resources::Candlepin::Consumer.refresh_entitlements(subscription_facet.uuid)
-          end
-
           if consumer_params.try(:[], :facts)
             ::Katello::Host::SubscriptionFacet.update_facts(self, consumer_params[:facts])
           end

data/app/models/katello/content_view_deb_filter.rb

@@ -13,6 +13,8 @@ module Katello
         package_filenames.concat(query_debs(repo, rule))
       end
 
+      package_filenames = package_filenames.uniq.sort
+
       ContentViewDebFilter.generate_deb_clauses(package_filenames)
     end
 
@@ -21,6 +23,9 @@ module Katello
       self.deb_rules.each do |rule|
         deb_filenames.concat(query_debs(repo, rule))
       end
+
+      deb_filenames = deb_filenames.uniq
+
       debs = Deb.in_repositories(repo)
       debs.where(filename: deb_filenames).pluck(:pulp_id).flatten.uniq
     end
@@ -45,6 +50,11 @@ module Katello
         query_arch = rule.architecture.tr("*", "%")
         query = query.where("#{Deb.table_name}.architecture ilike ?", query_arch)
       end
+      if rule.version.present?
+        query = query.search_version_equal(rule.version)
+      elsif rule.min_version.present? || rule.max_version.present?
+        query = query.search_version_range(rule.min_version, rule.max_version)
+      end
       query.default_sort
     end
   end

data/app/models/katello/content_view_deb_filter_rule.rb

@@ -10,10 +10,17 @@ module Katello
     validates :name, :presence => true
     validate :ensure_unique_attributes
     validates_with Validators::ContentViewFilterVersionValidator
+    scoped_search :on => :version, :complete_value => true
+    scoped_search :on => :min_version, :complete_value => true
+    scoped_search :on => :max_version, :complete_value => true
+    scoped_search :on => :architecture, :complete_value => true
 
     def ensure_unique_attributes
       other = self.class.where(:name => self.name,
+                               :version => self.version,
                                :content_view_filter_id => self.content_view_filter_id,
+                               :min_version => self.min_version,
+                               :max_version => self.max_version,
                                :architecture => self.architecture)
       other = other.where.not(:id => self.id) if self.id
       if other.exists?

data/app/models/katello/deb.rb

@@ -27,16 +27,16 @@ module Katello
       ContentFacetApplicableDeb
     end
 
-    def self.search_version_range(min = nil, max = nil)
-      query = self.all
-      query = Katello::Util::PackageFilter.new(query, min, Katello::Util::PackageFilter::GREATER_THAN).results if min
-      query = Katello::Util::PackageFilter.new(query, max, Katello::Util::PackageFilter::LESS_THAN).results if max
+    scope :search_version_equal, ->(ver) {
+      where("deb_version_cmp(#{::Katello::Deb.table_name}.version, ?) = 0", ver)
+    }
+
+    scope :search_version_range, ->(min_ver, max_ver) {
+      query = all
+      query = query.where("deb_version_cmp(#{::Katello::Deb.table_name}.version, ?) >= 0", min_ver) if min_ver.present?
+      query = query.where("deb_version_cmp(#{::Katello::Deb.table_name}.version, ?) <= 0", max_ver) if max_ver.present?
       query
-    end
-
-    def self.search_version_equal(version)
-      Katello::Util::PackageFilter.new(self, version, Katello::Util::PackageFilter::EQUAL).results
-    end
+    }
 
     def self.total_for_repositories(repos)
       self.in_repositories(repos).count
@@ -96,7 +96,7 @@ module Katello
 
     # Return deb packages that are not installed on a host, but could be installed
     # the word 'installable' has a different meaning here than elsewhere
-    def self.apt_installable_for_host(host)
+    def self.deb_installable_for_host(host)
       repos = host.content_facet.bound_repositories.pluck(:id)
       Katello::Deb.in_repositories(repos).where.not(name: host.installed_debs.pluck(:name)).order(:name)
     end

data/app/models/katello/erratum.rb

@@ -227,7 +227,7 @@ module Katello
       property :summary, String, desc: 'Returns the errata summary, the length can very, it is usually in range of 60 to 1000 characters. It can include empty line characters.'
     end
     class Jail < ::Safemode::Jail
-      allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested, :title, :summary
+      allow :errata_id, :errata_type, :issued, :updated, :created_at, :severity, :package_names, :cves, :reboot_suggested, :title, :summary
     end
   end
 end

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

@@ -31,10 +31,21 @@ module Katello
     end
 
     module InstanceMethods
-      API_URL = 'https://subscription.rhsm.redhat.com/subscription/consumers/'.freeze
+      API_BASE_URL = 'https://subscription.rhsm.redhat.com'.freeze
+      SUBSCRIPTION_PATH = '/subscription'.freeze
+      CONSUMERS_PATH = '/consumers/'.freeze
+      API_URL = API_BASE_URL + SUBSCRIPTION_PATH + CONSUMERS_PATH # https://subscription.rhsm.redhat.com/subscription/consumers/
+
+      def normalize_api_url(api_url)
+        return nil if api_url.blank?
+        uri = URI.parse(api_url)
+        # only take base url; we will overwrite the path to ensure it's correct
+        uri.path = SUBSCRIPTION_PATH + CONSUMERS_PATH # https://subscription.rhsm.redhat.com/subscription/consumers/
+        uri.to_s
+      end
+
       def api_url(upstream = {})
-        # Default to Red Hat
-        ENV['REDHAT_RHSM_API_URL'] || upstream['apiUrl'] || API_URL
+        ENV['REDHAT_RHSM_API_URL'] || normalize_api_url(upstream['apiUrl']) || API_URL
       end
 
       def sync

data/app/models/katello/host/content_facet.rb

@@ -202,7 +202,7 @@ module Katello
         #           "/pulp/content/Org/Library/custom/Test_product/test2/%3Fcomp%3Dmain%26rel%3Dstable"]
         paths.each do |path|
           if (prefix = prefixes.find { |pre| path.start_with?(pre) })
-            # strip prefix and structured_apt postfix before adding to relative_paths
+            # strip prefix and deb? content postfix before adding to relative_paths
             relative_paths << path.sub(prefix, '').sub(%r{/?(%3F|\?).*}, '')
           else
             Rails.logger.warn("System #{self.host.name} (#{self.host.id}) requested binding to repo with unknown prefix. #{path}")

data/app/models/katello/host/subscription_facet.rb

@@ -51,7 +51,6 @@ module Katello
           self.dmi_uuid = consumer_params['facts']['dmi.system.uuid']
         end
 
-        self.autoheal = consumer_params['autoheal'] unless consumer_params['autoheal'].nil?
         self.service_level = consumer_params['serviceLevel'] unless consumer_params['serviceLevel'].nil?
         self.registered_at = consumer_params['created'] unless consumer_params['created'].blank?
         self.last_checkin = consumer_params['lastCheckin'] unless consumer_params['lastCheckin'].blank?
@@ -130,7 +129,6 @@ module Katello
 
       def consumer_attributes
         attrs = {
-          :autoheal => autoheal,
           :usage => purpose_usage,
           :role => purpose_role,
           :serviceLevel => service_level,
@@ -257,10 +255,6 @@ module Katello
         Katello::Product.joins(:subscriptions => {:pools => :subscription_facets}).where("#{Katello::Host::SubscriptionFacet.table_name}.id" => self.id).enabled.uniq
       end
 
-      def remove_subscriptions(pools_with_quantities)
-        ForemanTasks.sync_task(Actions::Katello::Host::RemoveSubscriptions, self.host, pools_with_quantities)
-      end
-
       def self.sanitize_name(name)
         name.gsub('_', '-').chomp('.').downcase
       end
@@ -274,7 +268,7 @@ module Katello
       end
 
       def backend_update_needed?
-        %w(release_version service_level autoheal purpose_role purpose_usage).each do |method|
+        %w(release_version service_level purpose_role purpose_usage).each do |method|
           if self.send("#{method}_changed?")
             Rails.logger.debug("backend_update_needed: subscription facet #{method} changed")
             return true

data/app/models/katello/product_content.rb

@@ -46,8 +46,8 @@ module Katello
 
     def self.enabled(organization)
       content_ids = Katello::RootRepository.in_organization(organization).where.not(content_id: nil).pluck(:content_id)
-      structured_apt_content_ids = Katello::Repository.in_organization(organization).library.pluck(:content_id)
-      joins(:content).where("#{self.content_table_name}.cp_content_id" => content_ids + structured_apt_content_ids)
+      deb_content_ids = Katello::Repository.in_organization(organization).library.deb_type.pluck(:content_id)
+      joins(:content).where("#{self.content_table_name}.cp_content_id" => content_ids + deb_content_ids)
     end
 
     def self.with_valid_subscription(organization)

data/app/models/katello/repository.rb

@@ -170,7 +170,7 @@ module Katello
     scoped_search :on => :label, :relation => :root, :complete_value => true, :only_explicit => true
     scoped_search :on => :content_label, :ext_method => :search_by_content_label, :default_operator => :like
 
-    delegate :product, :redhat?, :custom?, :deb_using_structured_apt?, :to => :root
+    delegate :product, :redhat?, :custom?, :to => :root
     delegate :yum?, :docker?, :deb?, :file?, :ostree?, :ansible_collection?, :generic?, :to => :root
     delegate :name, :label, :docker_upstream_name, :url, :download_concurrency, :to => :root
 
@@ -1046,32 +1046,13 @@ module Katello
 
     def deb_content_url_options
       return '' unless version_href
-      return '' if backend_service(SmartProxy.pulp_primary).version_missing_structure_content?
 
-      components = deb_pulp_components.join(',')
-      distributions = deb_pulp_distributions.join(',')
+      backend_service = self.backend_service(SmartProxy.pulp_primary)
+      components = backend_service.pulp_components.join(',')
+      distributions = backend_service.pulp_distributions.join(',')
       "/?comp=#{components}&rel=#{distributions}"
     end
 
-    def deb_pulp_components(version_href = self.version_href)
-      return [] if version_href.blank?
-
-      pulp_api = Katello::Pulp3::Repository.instance_for_type(self, SmartProxy.pulp_primary).api.content_release_components_api
-      pulp_api.list({:repository_version => version_href}).results.map { |x| x.plain_component }.uniq
-    end
-
-    def deb_sanitize_pulp_distribution(distribution)
-      return "flat-repo" if distribution == "/"
-      return distribution.chomp("/") if distribution&.end_with?("/")
-      distribution
-    end
-
-    def deb_pulp_distributions(version_href = self.version_href)
-      return [] if version_href.blank?
-      pulp_api = Katello::Pulp3::Repository.instance_for_type(self, SmartProxy.pulp_primary).api.content_release_components_api
-      pulp_api.list({:repository_version => version_href}).results.map { |x| deb_sanitize_pulp_distribution(x.distribution) }.uniq
-    end
-
     def sync_status
       return latest_dynflow_sync
     end

data/app/models/katello/root_repository.rb

@@ -389,10 +389,6 @@ module Katello
       self.content_type == Repository::DEB_TYPE
     end
 
-    def deb_using_structured_apt?
-      self.deb? && !self.content_id
-    end
-
     def ansible_collection?
       self.content_type == Repository::ANSIBLE_COLLECTION_TYPE
     end
@@ -446,7 +442,8 @@ module Katello
     end
 
     def format_arches
-      if content_type == ::Katello::Repository::DEB_TYPE
+      if self.deb?
+        # Pulp 2 needed a "," separated string-list, but Pulp 3 needs " " separated!
         self.deb_architectures&.gsub(" ", ",")
       else
         self.arch == "noarch" ? nil : self.arch

data/app/services/katello/candlepin/event_handler.rb

@@ -15,46 +15,13 @@ module Katello
           @message_handler = ::Katello::Candlepin::MessageHandler.new(message)
           data[:entity_id] = @message_handler.entity_id
           case message_handler.subject
-          when /entitlement\.created/
-            message_handler.import_pool
-            message_handler.create_pool_on_host
-          when /entitlement\.deleted/
-            message_handler.import_pool
-            message_handler.remove_pool_from_host
           when /pool\.created/
             message_handler.import_pool
           when /pool\.deleted/
             message_handler.delete_pool
-          when /^compliance\.created/
-            event_no_longer_handled
-          when /system_purpose_compliance\.created/
-            event_no_longer_handled
-          when /owner_content_access_mode\.modified/
-            message_handler.handle_content_access_mode_modified
           end
         end
       end
-
-      private
-
-      def event_no_longer_handled
-        @logger.error "Received #{message_handler.subject} event from Candlepin. Handling of this event is no longer supported."
-      end
-
-      def subscription_facet
-        message_handler.subscription_facet
-      end
-
-      def reindex_consumer
-        if subscription_facet.nil?
-          @logger.debug "skip re-indexing of non-existent content host #{message_handler.consumer_uuid}"
-          return
-        end
-
-        @logger.debug "re-indexing content host #{subscription_facet.host.name}"
-
-        yield
-      end
     end
   end
 end

data/app/services/katello/candlepin/message_handler.rb

@@ -46,27 +46,9 @@ module Katello
         case subject
         when 'pool.created', 'pool.deleted'
           content['entityId']
-        when 'entitlement.created', 'entitlement.deleted'
-          content['referenceId']
         end
       end
 
-      def create_pool_on_host
-        return if self.subscription_facet.nil? || pool.nil?
-        old_host_ids = subscription_facet_host_ids
-        ::Katello::SubscriptionFacetPool.where(subscription_facet_id: self.subscription_facet.id,
-                                               pool_id: pool.id).first_or_create
-        pool.import_audit_record(old_host_ids)
-      end
-
-      def remove_pool_from_host
-        return if self.subscription_facet.nil? || pool.nil?
-        old_host_ids = subscription_facet_host_ids
-        ::Katello::SubscriptionFacetPool.where(subscription_facet_id: self.subscription_facet.id,
-                                               pool_id: pool.id).destroy_all
-        pool.import_audit_record(old_host_ids)
-      end
-
       def import_pool(index_hosts = true)
         if pool
           ::Katello::EventQueue.push_event(::Katello::Events::ImportPool::EVENT_TYPE, pool.id)
@@ -86,29 +68,6 @@ module Katello
           Rails.logger.info "Deleted Katello::Pool with cp_id=#{pool_id}"
         end
       end
-
-      def handle_content_access_mode_modified
-        # Ideally the target_name would be the Candlepin Owner key
-        # Since it's the displayName, and we don't update that after org creation, there could be a mismatch
-        # For now, find the Candlepin Owner displayName from this event, and tie it back to a Katello org based on owner key
-        owners = Katello::Resources::Candlepin::Owner.all
-        owner = owners.find { |o| o['displayName'] == target_name }
-
-        unless owner
-          fail("Candlepin Owner %s could not be found" % target_name)
-        end
-
-        org = ::Organization.find_by!(label: owner['key'])
-
-        Rails.logger.error "Received content_access_mode_modified event for org #{org.label}. This event is no longer supported."
-        org.simple_content_access?(cached: false)
-      end
-
-      private
-
-      def subscription_facet_host_ids
-        ::Katello::SubscriptionFacetPool.where(pool_id: pool_id).joins(:subscription_facet).pluck(:host_id)
-      end
     end
   end
 end