katello 3.15.3.1 → 3.16.0.rc1

data/app/models/katello/repository.rb

@@ -56,8 +56,9 @@ module Katello
     has_many :repository_srpms, :class_name => "Katello::RepositorySrpm", :dependent => :delete_all
     has_many :srpms, :through => :repository_srpms
 
-    has_many :repository_file_units, :class_name => "Katello::RepositoryFileUnit", :dependent => :destroy
+    has_many :repository_file_units, :class_name => "Katello::RepositoryFileUnit", :dependent => :delete_all
     has_many :files, :through => :repository_file_units, :source => :file_unit
+    alias_attribute :file_units, :files
 
     has_many :repository_puppet_modules, :class_name => "Katello::RepositoryPuppetModule", :dependent => :delete_all
     has_many :puppet_modules, :through => :repository_puppet_modules
@@ -82,7 +83,7 @@ module Katello
     has_many :repository_debs, :class_name => "Katello::RepositoryDeb", :dependent => :delete_all
     has_many :debs, :through => :repository_debs
 
-    has_many :content_facet_repositories, :class_name => "Katello::ContentFacetRepository", :dependent => :destroy
+    has_many :content_facet_repositories, :class_name => "Katello::ContentFacetRepository", :dependent => :delete_all
     has_many :content_facets, :through => :content_facet_repositories
 
     has_many :repository_package_groups, :class_name => "Katello::RepositoryPackageGroup", :dependent => :delete_all
@@ -171,6 +172,10 @@ module Katello
       joins(:root).where("#{RootRepository.table_name}.content_type" => content_type)
     end
 
+    def to_label
+      name
+    end
+
     def backend_service(smart_proxy, force_pulp3 = false)
       if force_pulp3 || smart_proxy.pulp3_support?(self)
         @service ||= Katello::Pulp3::Repository.instance_for_type(self, smart_proxy)
@@ -195,6 +200,10 @@ module Katello
       end
     end
 
+    def organization_id
+      organization&.id
+    end
+
     def audit_sync
       write_audit(action: AUDIT_SYNC_ACTION, comment: _('Successfully synchronized.'), audited_changes: {})
     end
@@ -267,7 +276,7 @@ module Katello
     end
 
     def in_default_view?
-      content_view_version && content_view_version.default_content_view?
+      content_view_version&.default_content_view?
     end
 
     def on_demand?
@@ -385,7 +394,7 @@ module Katello
     end
 
     def promoted?
-      if environment && environment.library?
+      if environment&.library?
         self.clones.any?
       else
         false
@@ -422,12 +431,8 @@ module Katello
       path
     end
 
-    def library_instance_or_self
-      self.library_instance || self
-    end
-
     def generate_repo_path(content_path = nil)
-      _org, _content, content_path = library_instance_or_self.relative_path.split("/", 3) if content_path.blank?
+      _org, _content, content_path = (self.library_instance || self).relative_path.split("/", 3) if content_path.blank?
       content_path = content_path.sub(%r|^/|, '')
       if self.environment
         cve = ContentViewEnvironment.where(:environment_id => self.environment,
@@ -500,7 +505,7 @@ module Katello
         end
       end
       clone = Repository.new(:environment => to_env,
-                     :library_instance => library_instance_or_self,
+                     :library_instance => self.library_instance || self,
                      :root => self.root,
                      :content_view_version => to_version,
                      :saved_checksum_type => checksum_type)
@@ -618,7 +623,7 @@ module Katello
 
     def import_distribution_data(target_repo = nil)
       if target_repo
-        self.update_attributes!(
+        self.update!(
           :distribution_version => target_repo.distribution_version,
           :distribution_arch => target_repo.distribution_arch,
           :distribution_family => target_repo.distribution_family,

data/app/models/katello/root_repository.rb

@@ -97,7 +97,7 @@ module Katello
     scope :with_no_proxy, -> { where(:http_proxy_policy => RootRepository::NO_DEFAULT_HTTP_PROXY) }
     scope :with_selected_proxy, ->(http_proxy_id) {
       where(:http_proxy_policy => RootRepository::USE_SELECTED_HTTP_PROXY).
-      where(:http_proxy_id => http_proxy_id)
+      where("http_proxy_id = ?", http_proxy_id)
     }
     delegate :redhat?, :provider, :organization, to: :product
 
@@ -325,6 +325,14 @@ module Katello
       super
     end
 
+    def format_arches
+      if content_type == ::Katello::Repository::DEB_TYPE
+        self.deb_architectures
+      else
+        self.arch == "noarch" ? nil : self.arch
+      end
+    end
+
     class Jail < ::Safemode::Jail
       allow :name, :label, :docker_upstream_name, :url
     end

data/app/models/katello/rpm.rb

@@ -6,7 +6,8 @@ module Katello
     has_many :content_facet_applicable_rpms, :class_name => "Katello::ContentFacetApplicableRpm",
              :dependent => :destroy, :inverse_of => :rpm
     has_many :content_facets, :through => :content_facet_applicable_rpms, :class_name => "Katello::Host::ContentFacet"
-
+    has_many :module_stream_rpms, class_name: "Katello::ModuleStreamRpm", inverse_of: :rpm, dependent: :destroy
+    has_many :module_streams, :through => :module_stream_rpms
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version, :complete_value => true, :ext_method => :scoped_search_version
     scoped_search :on => :release, :complete_value => true, :ext_method => :scoped_search_release

data/app/models/katello/subscription.rb

@@ -5,6 +5,7 @@ module Katello
     include Katello::Authorization::Subscription
 
     has_many :pools, :class_name => "Katello::Pool", :inverse_of => :subscription, :dependent => :destroy
+    has_many :products, :class_name => "Katello::Product", :through => :pools
 
     belongs_to :organization, :class_name => "Organization", :inverse_of => :subscriptions
 
@@ -24,10 +25,7 @@ module Katello
     end
 
     def redhat?
-      # for custom subscriptions, there is no separate marketing and engineering product
-      #   so query our Products table and check there
-      product = Katello::Product.where(:cp_id => self.cp_id, :organization => self.organization).first
-      product.nil? || product.redhat?
+      products.redhat.any?
     end
 
     def active?

data/app/models/katello/sync_plan.rb

@@ -69,7 +69,7 @@ module Katello
       transaction do
         fail _("No recurring logic tied to the sync plan.") if self.foreman_tasks_recurring_logic.nil?
         params["cron_expression"] = '' if (params.key?("interval") && !params["interval"].eql?(CUSTOM_CRON) && self.interval.eql?(CUSTOM_CRON))
-        self.update_attributes!(params.except(:enabled))
+        self.update!(params.except(:enabled))
         if (rec_logic_changed? || (params["enabled"] && !self.enabled? && self.foreman_tasks_recurring_logic.cancelled?))
           old_rec_logic = self.foreman_tasks_recurring_logic
           associate_recurring_logic
@@ -114,7 +114,7 @@ module Katello
     end
 
     def cancel_recurring_logic
-      self.foreman_tasks_recurring_logic.cancel if self.foreman_tasks_recurring_logic
+      self.foreman_tasks_recurring_logic&.cancel
     end
 
     def validate_sync_date

data/app/models/katello/task_status.rb

@@ -151,7 +151,7 @@ module Katello
     end
 
     # TODO: break up method
-    # rubocop:disable MethodLength
+    # rubocop:disable Metrics/MethodLength
     def message
       # Retrieve a text message that may be rendered for a task's status.  This is used in various places,
       # such as System Event history.

data/app/models/katello/trace_status.rb

@@ -35,7 +35,7 @@ module Katello
     end
 
     def to_status(_options = {})
-      if host.host_traces.where(:app_type => "static").any?
+      if host.host_traces.reboot_required.any?
         REQUIRE_REBOOT
       elsif host.host_traces.where.not(:app_type => "session").any?
         REQUIRE_PROCESS_RESTART
@@ -46,8 +46,8 @@ module Katello
 
     def relevant?(_options = {})
       # traces cannot be reported from hosts lower than el7
-      return false if host.operatingsystem.try(:major).to_i.between?(1, 6)
-      host.content_facet.try(:uuid)
+      return false if host.operatingsystem.try(:major).to_i.between?(1, 6) || !host.content_facet&.tracer_installed?
+      host.content_facet.try(:uuid).present?
     end
   end
 end

data/app/models/setting/content.rb

@@ -2,7 +2,7 @@ class Setting::Content < Setting
   #rubocop:disable Metrics/MethodLength
   #rubocop:disable Metrics/AbcSize
 
-  validate :content_default_http_proxy, if: proc { |s| s.name == 'content_default_http_proxy' && HttpProxy.table_exists? }
+  validate :content_default_http_proxy, if: proc { |s| s.name == 'content_default_http_proxy' }
 
   after_save :add_organizations_and_locations_if_global_http_proxy
 
@@ -20,6 +20,7 @@ class Setting::Content < Setting
 
     proxy_download_policies = proc { deprecate_background(hashify_parameters(::SmartProxy::DOWNLOAD_POLICIES)) }
     dependency_solving_options = proc { hashify_parameters(['conservative', 'greedy']) }
+    cdn_ssl_versions = proc { hashify_parameters(Katello::Resources::CDN::SUPPORTED_SSL_VERSIONS) }
     http_proxy_select = [{
       name: _("HTTP Proxies"),
       class: 'HttpProxy',
@@ -34,6 +35,9 @@ class Setting::Content < Setting
                       nil,
                       collection: proc { http_proxy_select }, include_blank: N_("no global default")
               ),
+      self.set('cdn_ssl_version', N_("SSL version used to communicate with the CDN"),
+               nil, N_('CDN SSL version'), nil,
+               :collection => cdn_ssl_versions),
       self.set('katello_default_provision', N_("Default provisioning template for Operating Systems created from synced content"),
                'Kickstart default', N_('Default synced OS provisioning template'),
                nil, :collection => proc { katello_template_setting_values("provision") }
@@ -147,7 +151,7 @@ class Setting::Content < Setting
 
   def self.load_defaults
     BLANK_ATTRS.concat %w(register_hostname_fact default_location_subscribed_hosts
-                          default_location_puppet_content content_default_http_proxy host_dmi_uuid_duplicates)
+                          default_location_puppet_content content_default_http_proxy host_dmi_uuid_duplicates cdn_ssl_version)
     super
   end
 

data/app/services/katello/applicability/applicable_content_helper.rb

@@ -0,0 +1,121 @@
+module Katello
+  module Applicability
+    class ApplicableContentHelper
+      attr_accessor :content_facet, :content_unit_class, :bound_library_instance_repos
+
+      def initialize(content_facet, content_unit_class, bound_library_instance_repos)
+        self.content_facet = content_facet
+        self.content_unit_class = content_unit_class
+        self.bound_library_instance_repos = bound_library_instance_repos
+      end
+
+      def calculate_and_import
+        if self.bound_library_instance_repos.any?
+          to_add, to_remove = applicable_differences
+          ActiveRecord::Base.transaction do
+            insert(to_add) unless to_add.blank?
+            remove(to_remove) unless to_remove.blank?
+          end
+        end
+      end
+
+      def fetch_content_ids
+        if self.content_unit_class == ::Katello::Erratum
+          fetch_errata_content_ids
+        elsif self.content_unit_class == ::Katello::ModuleStream
+          fail NotImplementedError
+        else
+          fetch_rpm_content_ids
+        end
+      end
+
+      def fetch_errata_content_ids
+        # Query for all Errata ids that are attached to the host's applicable packages
+        query = 'select katello_repository_errata.erratum_id as id from katello_repository_errata
+                     inner join katello_erratum_packages
+                        on  katello_repository_errata.erratum_id  = katello_erratum_packages.erratum_id
+                     inner join katello_rpms
+                        on katello_rpms.nvra = katello_erratum_packages.nvrea
+                     inner join katello_content_facet_applicable_rpms on
+                         katello_content_facet_applicable_rpms.rpm_id = katello_rpms.id
+                     where
+                          "katello_content_facet_applicable_rpms"."content_facet_id" = :content_facet_id
+                     AND katello_repository_errata.repository_id IN (:repo_ids)'
+
+        return Katello::Erratum.find_by_sql([query, {content_facet_id: content_facet.id, repo_ids: self.bound_library_instance_repos} ]).map(&:id).uniq
+      end
+
+      def fetch_rpm_content_ids
+        # Query for applicable RPM ids
+        # -> Include all non-modular rpms or rpms that exist within installed module streams
+        enabled_module_stream_ids = ::Katello::ModuleStream.
+          joins("inner join katello_available_module_streams on
+            katello_module_streams.name = katello_available_module_streams.name and
+            katello_module_streams.stream = katello_available_module_streams.stream").
+          joins("inner join katello_host_available_module_streams on
+            katello_available_module_streams.id = katello_host_available_module_streams.available_module_stream_id").
+          where("katello_host_available_module_streams.host_id = :content_facet_id and
+            katello_host_available_module_streams.status = 'enabled'",
+            :content_facet_id => self.content_facet.host.id).select(:id)
+
+        ::Katello::Rpm.
+          joins("INNER JOIN katello_repository_rpms ON
+            katello_rpms.id = katello_repository_rpms.rpm_id").
+          joins("INNER JOIN katello_installed_packages ON
+            katello_rpms.name = katello_installed_packages.name AND
+            katello_rpms.arch = katello_installed_packages.arch AND
+            katello_rpms.evr > katello_installed_packages.evr").
+          joins("LEFT JOIN katello_module_stream_rpms ON
+            katello_rpms.id = katello_module_stream_rpms.rpm_id").
+          joins("INNER JOIN katello_host_installed_packages ON
+            katello_installed_packages.id = katello_host_installed_packages.installed_package_id").
+          where("katello_repository_rpms.repository_id in (:bound_library_repos)",
+            :bound_library_repos => self.bound_library_instance_repos).
+          where("katello_host_installed_packages.host_id = :content_facet_id",
+            :content_facet_id => self.content_facet.host.id).
+          where("katello_module_stream_rpms.module_stream_id is null or
+            katello_module_stream_rpms.module_stream_id in (:enabled_module_streams)",
+            :enabled_module_streams => enabled_module_stream_ids).pluck(:id).uniq
+      end
+
+      def applicable_differences
+        consumer_ids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.id")
+        content_ids = fetch_content_ids
+
+        to_remove = consumer_ids - content_ids
+        to_add = content_ids - consumer_ids
+
+        [to_add, to_remove]
+      end
+
+      def insert(applicable_ids)
+        unless applicable_ids.empty?
+          inserts = applicable_ids.map { |applicable_id| "(#{applicable_id.to_i}, #{content_facet.id.to_i})" }
+          sql = "INSERT INTO #{content_facet_association_class.table_name} (#{content_unit_association_id}, content_facet_id) VALUES #{inserts.join(', ')}"
+          ActiveRecord::Base.connection.execute(sql)
+        end
+      end
+
+      def remove(applicable_ids)
+        content_facet_association_class.where(:content_facet_id => content_facet.id, content_unit_association_id => applicable_ids).delete_all
+      end
+
+      def content_unit_association_id
+        "#{content_unit_class.name.demodulize.underscore}_id".to_sym
+      end
+
+      def content_facet_association_class
+        # Example: ContentFacetErratum
+        self.content_unit_class.content_facet_association_class
+      end
+
+      def content_units
+        content_unit_class.name.demodulize.pluralize.underscore.to_sym
+      end
+
+      def applicable_units
+        "applicable_#{content_units}".to_sym
+      end
+    end
+  end
+end

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

@@ -84,7 +84,7 @@ module Katello
         filtered = entitlements
         filtered = filtered.select { |ent| ent['pool']['id'].to_s == pool_id.to_s } if pool_id
 
-        if quantities && quantities.any?
+        if quantities&.any?
           quantities.map!(&:to_s)
           filtered = quantities.map do |quantity|
             index = filtered.index { |ent| ent['quantity'].to_s == quantity }

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

@@ -13,12 +13,11 @@ module Katello
       end
 
       def content
-        JSON.parse(@message.content)
+        @content ||= JSON.parse(message.content)
       end
 
       def event_data
-        data = content['eventData']
-        data ? JSON.parse(data) : {}
+        @event_data ||= (data = content['eventData']) ? JSON.parse(data) : {}
       end
 
       def status

data/app/services/katello/candlepin_event_listener.rb

@@ -2,29 +2,43 @@ module Katello
   class CandlepinEventListener
     STATUS_CACHE_KEY = 'candlepin_events_status'.freeze
 
-    CandlepinEvent = Struct.new(:message_id, :subject, :content)
+    Event = Struct.new(:subject, :content)
+
+    cattr_accessor :client_factory
 
-    @logger = ::Foreman::Logging.logger('katello/candlepin_events')
     @failed_count = 0
     @processed_count = 0
 
-    def self.run
-      initialize_listening_service
+    def self.logger
+      ::Foreman::Logging.logger('katello/candlepin_events')
+    end
+
+    def self.running?
+      @running == true && @client&.running?
+    end
+
+    def self.close
+      return unless running?
 
-      result = Katello::CandlepinListeningService.instance.start
-      return unless result == :connected
+      logger.info("Closing candlepin event listener")
+      @client&.close
+      reset
+    end
 
-      Katello::CandlepinListeningService.instance.poll_for_messages do |message|
-        if message[:result]
-          result = message[:result]
-          event = CandlepinEvent.new(result.message_id, result.subject, result.content)
-          act_on_event(event)
-        end
+    def self.reset
+      @processed_count = 0
+      @failed_count = 0
+      @running = false
+      Rails.cache.delete(STATUS_CACHE_KEY)
+    end
+
+    def self.run
+      @client = client_factory.call
+      @client.subscribe do |message|
+        handle_message(message)
       end
-    rescue => e
-      @logger.error("Fatal error in Candlepin Listening Service")
-      close
-      raise e
+
+      @running = true
     end
 
     def self.status(refresh: true)
@@ -32,51 +46,23 @@ module Katello
         {
           processed_count: @processed_count,
           failed_count: @failed_count,
-          running: Katello::CandlepinListeningService.instance&.running? || false
+          running: running?
         }
       end
     end
 
-    def self.reset_status
-      @processed_count = 0
-      @failed_count = 0
-      Rails.cache.delete(STATUS_CACHE_KEY)
-    end
-
-    def self.act_on_event(event)
-      ::Katello::Util::Support.with_db_connection(@logger) do
-        ::Katello::Candlepin::EventHandler.new(@logger).handle(event)
+    def self.handle_message(message)
+      ::Katello::Util::Support.with_db_connection(logger) do
+        subject = "#{message.headers['EVENT_TARGET']}.#{message.headers['EVENT_TYPE']}".downcase
+        cp_event = Event.new(subject, message.body)
+        ::Katello::Candlepin::EventHandler.new(logger).handle(cp_event)
       end
       @processed_count += 1
     rescue => e
       @failed_count += 1
-      @logger.error("Error handling Candlepin event")
-      @logger.error(e.message)
-      @logger.error(e.backtrace.join("\n"))
-    end
-
-    def self.configured?
-      SETTINGS[:katello].key?(:qpid) &&
-        SETTINGS[:katello][:qpid].key?(:url) &&
-        SETTINGS[:katello][:qpid].key?(:subscriptions_queue_address)
-    end
-
-    def self.initialize_listening_service
-      if configured?
-        Katello::CandlepinListeningService.initialize_service(@logger,
-                                           SETTINGS[:katello][:qpid][:url],
-                                           SETTINGS[:katello][:qpid][:subscriptions_queue_address])
-      else
-        fail("Katello has not been configured for qpid.url and qpid.subscriptions_queue_address")
-      end
-    rescue => e
-      @logger.error(e.message)
-      @logger.error(e.backtrace)
-    end
-
-    def self.close
-      Katello::CandlepinListeningService.close
-      reset_status
+      logger.error("Error handling Candlepin event")
+      logger.error(e.message)
+      logger.error(e.backtrace.join("\n"))
     end
   end
 end