katello 3.15.1 → 3.16.0.rc2.1

data/app/lib/katello/lazy_accessor.rb

@@ -9,7 +9,7 @@ module Katello
       attr_accessor :lazy_attributes
 
       def lazy_attributes_options(attr)
-        if @lazy_attributes_options && @lazy_attributes_options.key?(attr)
+        if @lazy_attributes_options&.key?(attr)
           @lazy_attributes_options.fetch(attr.to_s)
         elsif superclass.respond_to?(:lazy_attributes_options)
           superclass.lazy_attributes_options(attr.to_s)
@@ -128,7 +128,9 @@ module Katello
         if self.respond_to?(:load_remote_data)
           load_remote_data(remote_values)
         else
-          remote_values.each_pair { |k, v| instance_variable_set("@#{k.to_s}", v) if (attrs && attrs.include?(k.to_sym) && respond_to?("#{k.to_s}=")) }
+          remote_values.each_pair do |k, v|
+            instance_variable_set("@#{k.to_s}", v) if (attrs&.include?(k.to_sym) && respond_to?("#{k.to_s}="))
+          end
         end
       end
     end

data/app/lib/katello/messaging/connection.rb

@@ -0,0 +1,15 @@
+module Katello
+  module Messaging
+    class Connection
+      def self.create(connection_class:, settings:)
+        connection = connection_class.new(settings: settings)
+
+        at_exit do
+          connection.close
+        end
+
+        connection
+      end
+    end
+  end
+end

data/app/lib/katello/messaging/received_message.rb

@@ -0,0 +1,12 @@
+module Katello
+  module Messaging
+    class ReceivedMessage
+      attr_reader :headers, :body
+
+      def initialize(body:, headers:)
+        @body = body
+        @headers = headers
+      end
+    end
+  end
+end

data/app/lib/katello/messaging/stomp_connection.rb

@@ -0,0 +1,73 @@
+require 'stomp'
+
+module Katello
+  module Messaging
+    class StompConnection
+      def initialize(settings:)
+        ssl_params = Stomp::SSLParams.new(
+          key_file: settings[:ssl_key_file],
+          cert_file: settings[:ssl_cert_file],
+          ts_files: settings[:ssl_ca_file],
+          fsck: false
+        )
+
+        @config = {
+          hosts: [
+            {
+              host: settings[:broker_host],
+              port: settings[:broker_port],
+              ssl: ssl_params
+            }
+          ],
+          logger: Rails.logger,
+          max_reconnect_attempts: 2,
+          start_timeout: 2,
+          reliable: false,
+          connect_headers: {
+            'accept-version': '1.2',
+            'host': settings[:broker_host],
+            'heart-beat': '30000,30000',
+            'client-id': settings[:client_id]
+          }
+        }
+
+        @queue_name = settings[:queue_name]
+        @subscription_name = settings[:subscription_name]
+      end
+
+      def subscribe(queue_name: @queue_name, subscription_name: @subscription_name)
+        options = {}
+        options['ack'] = 'client-individual'
+        options['durable-subscription-name'] = subscription_name if subscription_name
+
+        client.subscribe(queue_name, options) do |message|
+          received_message = Katello::Messaging::ReceivedMessage.new(body: message.body, headers: message.headers)
+          yield(received_message)
+          client.ack(message)
+        end
+
+        Rails.logger.info("Subscribed to #{queue_name}.#{subscription_name}")
+      end
+
+      def running?
+        @client&.running && @client&.open?
+      end
+
+      def open?
+        @client&.open?
+      end
+
+      def close
+        if open?
+          @client.close
+        end
+      end
+
+      private
+
+      def client
+        @client ||= ::Stomp::Client.new(@config)
+      end
+    end
+  end
+end

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

@@ -26,7 +26,6 @@ module Katello
             JSON.parse(response.body).with_indifferent_access
           end
 
-          # rubocop:disable Metrics/ParameterLists
           def update(id, release_version, service_level, auto_attach, purpose_role, purpose_usage, purpose_addons)
             attrs = { :releaseVer => release_version, :serviceLevel => service_level, :autoAttach => auto_attach, :role => purpose_role, :usage => purpose_usage, :addOns => purpose_addons }.delete_if { |_k, v| v.nil? }
             JSON.parse(self.put(path(id), attrs.to_json, self.default_headers).body).with_indifferent_access

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

@@ -6,7 +6,7 @@ module Katello
 
         def self.queues
           response = get("#{path}/queues")
-          JSON.parse(response.body).first
+          JSON.parse(response.body)
         end
 
         def self.queue_depth(queue_name)

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

@@ -61,6 +61,12 @@ module Katello
             JSON.parse(response).with_indifferent_access
           end
 
+          def hypervisors_heartbeat(owner:, reporter_id:)
+            url = "/candlepin/hypervisors/#{owner}/heartbeat?reporter_id=#{reporter_id}"
+            response = self.put(url, {}.to_json, self.default_headers).body
+            JSON.parse(response).with_indifferent_access
+          end
+
           def register_hypervisors(params)
             url = "/candlepin/hypervisors"
             url << "?owner=#{params[:owner]}&env=#{params[:env]}"

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

@@ -20,7 +20,13 @@ module Katello
 
           def destroy(owner_label, id)
             fail ArgumentError, "content id has to be specified" unless id
-            self.delete(path(owner_label, id), self.default_headers).code.to_i
+
+            begin
+              self.delete(path(owner_label, id), self.default_headers).code.to_i
+            rescue RestClient::NotFound
+              # this is OK
+              :content_gone
+            end
           end
 
           def update(owner_label, attrs)

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

@@ -118,15 +118,6 @@ module Katello
               JSON.parse(response)['systemPurposeAttributes']
             end
           end
-
-          def auto_attach(key)
-            response = self.post(join_path(path(key), 'entitlements'), "", self.default_headers).body
-            if response.empty?
-              return nil
-            else
-              JSON.parse(response)
-            end
-          end
         end
       end
     end

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

@@ -1,6 +1,7 @@
 module Katello
   module Resources
     module CDN
+      SUPPORTED_SSL_VERSIONS = ['SSLv23', 'TLSv1'].freeze
       class Utils
         # takes releasever from contentUrl (e.g. 6Server, 6.0, 6.1)
         # returns hash e.g. {:major => 6, :minor => "6.1"}
@@ -25,6 +26,10 @@ module Katello
         end
 
         def initialize(url, options = {})
+          @ssl_version = Setting[:cdn_ssl_version]
+          if @ssl_version && !SUPPORTED_SSL_VERSIONS.include?(@ssl_version)
+            fail("Invalid SSL version specified. Check the 'CDN SSL Version' setting")
+          end
           options.reverse_merge!(:verify_ssl => 9)
           options.assert_valid_keys(:ssl_client_key, :ssl_client_cert, :ssl_ca_file, :verify_ssl,
                                     :product)
@@ -66,7 +71,7 @@ module Katello
           # Run the following command in rails console to figure out other
           # valid constants in other ruby versions
           # "OpenSSL::SSL::SSLContext::METHODS"
-          net.ssl_version = SETTINGS[:katello][:cdn_ssl_version] if SETTINGS[:katello].key?(:cdn_ssl_version)
+          net.ssl_version = @ssl_version
 
           if (@options[:verify_ssl] == false) || (@options[:verify_ssl] == OpenSSL::SSL::VERIFY_NONE)
             net.verify_mode = OpenSSL::SSL::VERIFY_NONE

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

@@ -27,7 +27,7 @@ module Katello
             pulp_master = ::SmartProxy.pulp_master
 
             # Pulp 3 has its own registry
-            if pulp_master && pulp_master.pulp3_repository_type_support?(::Katello::Repository::DOCKER_TYPE)
+            if pulp_master&.pulp3_repository_type_support?(::Katello::Repository::DOCKER_TYPE)
               uri = URI(pulp_master.setting(SmartProxy::PULP3_FEATURE, 'content_app_url'))
               uri.path = "/pulpcore_registry/"
               registry_url = uri.to_s

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

@@ -66,9 +66,7 @@ module Katello
         end
 
         futures.each do |future|
-          begin
-            resolved << future.value
-          end
+          resolved << future.value
         end
 
         find_substitutions(resolved.compact.flatten)

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

data/app/mailers/katello/subscription_mailer.rb

@@ -0,0 +1,35 @@
+module Katello
+  class SubscriptionMailer < ApplicationMailer
+    helper :'katello/subscription_mailer'
+    after_action :prevent_sending_blank_report
+    include SubscriptionMailerHelper
+
+    def subscription_expiry(options)
+      user = ::User.find(options[:user])
+      days_from_now = options[:query]
+
+      ::User.as(user.login) do
+        @pools = Katello::Pool.readable.expiring_in_days(days_from_now)
+        @affected_hosts = ::Host::Managed.with_pools_expiring_in_days(days_from_now)
+      end
+
+      if @affected_hosts.any?
+        start_report_task(days_from_now)
+        @report_url = report_url
+        @report_link = report_link
+      end
+
+      set_locale_for(user) do
+        mail(:to => user.mail, :subject => _("You have subscriptions expiring within %s days") % days_from_now)
+      end
+    end
+
+    private
+
+    def prevent_sending_blank_report
+      if @pools.blank?
+        mail.perform_deliveries = false
+      end
+    end
+  end
+end

data/app/models/katello/activation_key.rb

@@ -34,6 +34,7 @@ module Katello
     validates_lengths_from_database
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
     validates :name, :presence => true
+    validates :name, :format => { without: /,/, message: _('cannot contain commas') }
     validates :name, :uniqueness => {:scope => :organization_id}
     validate :environment_exists
     validates :max_hosts, :numericality => {:less_than => 2**31, :allow_nil => true}

data/app/models/katello/ansible_collection.rb

@@ -1,5 +1,5 @@
 module Katello
-  class AnsibleCollection < ApplicationRecord
+  class AnsibleCollection < Katello::Model
     include Concerns::PulpDatabaseUnit
 
     self.table_name = 'katello_ansible_collections'

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

@@ -0,0 +1,14 @@
+module Katello
+  module Authorization::HostTracer
+    extend ActiveSupport::Concern
+
+    include Authorizable
+
+    module ClassMethods
+      def resolvable
+        relation = joins_authorized(::Host::Managed, :edit_hosts)
+        relation
+      end
+    end
+  end
+end

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

@@ -2,13 +2,17 @@ module Katello
   module Authorization::Pool
     extend ActiveSupport::Concern
 
+    include Authorizable
+
     def readable?
       self.class.readable.where(id: self.id).any?
     end
 
     module ClassMethods
       def readable
-        where(:subscription_id => Katello::Subscription.readable)
+        relation = joins_authorized(Katello::Subscription, :view_subscriptions)
+        relation = relation.where(organization_id: User.current.organization_ids) unless User.current.admin?
+        relation
       end
     end
   end

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

@@ -10,9 +10,7 @@ module Katello
 
     module ClassMethods
       def readable
-        return all if User.current.admin?
-
-        authorized(:view_subscriptions).where(organization_id: User.current.organization_ids)
+        authorized(:view_subscriptions)
       end
     end
   end

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

@@ -51,6 +51,8 @@ module Katello
         before_save :correct_puppet_environment
         before_validation :correct_kickstart_repository
 
+        scope :with_pools_expiring_in_days, ->(days) { joins(:pools).merge(Katello::Pool.expiring_in_days(days)).distinct }
+
         scoped_search :relation => :host_collections, :on => :id, :complete_value => false, :rename => :host_collection_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
         scoped_search :relation => :host_collections, :on => :name, :complete_value => true, :rename => :host_collection
         scoped_search :relation => :installed_packages, :on => :nvra, :complete_value => true, :rename => :installed_package, :only_explicit => true
@@ -61,6 +63,17 @@ module Katello
         scoped_search :relation => :host_traces, :on => :application, :complete_value => true, :rename => :trace_app, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :app_type, :complete_value => true, :rename => :trace_app_type, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :helper, :complete_value => true, :rename => :trace_helper, :only_explicit => true
+
+        scoped_search relation: :pools, on: :pools_expiring_in_days, ext_method: :find_with_expiring_pools, only_explicit: true
+
+        def self.find_with_expiring_pools(_key, _operator, days_from_now)
+          host_ids = with_pools_expiring_in_days(days_from_now).ids
+          if host_ids.any?
+            { :conditions => "hosts.id IN (#{host_ids.join(', ')})" }
+          else
+            { :conditions => "1=0" }
+          end
+        end
       end
 
       def correct_kickstart_repository
@@ -182,7 +195,7 @@ module Katello
           shared_keys = hams.attributes.keys & module_stream.keys
           module_stream_data = module_stream.slice(*shared_keys)
           if hams.attributes.slice(*shared_keys) != module_stream_data
-            hams.update_attributes!(module_stream_data)
+            hams.update!(module_stream_data)
           end
         end
       end
@@ -213,11 +226,15 @@ module Katello
       end
 
       def import_tracer_profile(tracer_profile)
-        self.host_traces.destroy_all
+        traces = []
         tracer_profile.each do |trace, attributes|
-          self.host_traces.create!(:application => trace, :helper => attributes[:helper], :app_type => attributes[:type])
+          next if attributes[:helper].blank?
+
+          traces << { host_id: self.id, application: trace, helper: attributes[:helper], app_type: attributes[:type] }
         end
-        self.update_trace_status
+        host_traces.delete_all
+        Katello::HostTracer.import(traces, validate: false)
+        update_trace_status
       end
 
       def subscription_status
@@ -280,6 +297,14 @@ module Katello
         @purpose_addons_status_label ||= get_status(::Katello::PurposeAddonsStatus).to_label(options)
       end
 
+      def traces_status
+        @traces_status ||= get_status(::Katello::TraceStatus).status
+      end
+
+      def traces_status_label(options = {})
+        @traces_status_label ||= get_status(::Katello::TraceStatus).to_label(options)
+      end
+
       def valid_content_override_label?(content_label)
         available_content = subscription_facet.candlepin_consumer.available_product_content
         available_content.map(&:content).any? { |content| content.label == content_label }
@@ -300,3 +325,7 @@ class ::Host::Managed::Jail < Safemode::Jail
         :host_collections, :comment, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
         :installed_packages
 end
+
+class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail
+  allow :expiring_in_days
+end