katello 3.15.3.1 → 3.16.0.rc1

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/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,13 @@ module Katello
       end
 
       def import_tracer_profile(tracer_profile)
-        self.host_traces.destroy_all
+        host_traces.delete_all
+        traces = []
         tracer_profile.each do |trace, attributes|
-          self.host_traces.create!(:application => trace, :helper => attributes[:helper], :app_type => attributes[:type])
+          traces << { host_id: self.id, application: trace, helper: attributes[:helper], app_type: attributes[:type] }
         end
-        self.update_trace_status
+        Katello::HostTracer.import(traces, validate: false)
+        update_trace_status
       end
 
       def subscription_status
@@ -280,6 +295,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 +323,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

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

@@ -8,7 +8,6 @@ module Katello
           :inverse_of => :http_proxy, :dependent => :nullify
         after_update :update_default_proxy_setting
         after_commit :update_repository_proxy_details
-        before_destroy :remove_references_to_proxy
 
         def self.default_global_content_proxy
           if Setting[:content_default_http_proxy]
@@ -17,34 +16,6 @@ module Katello
         end
       end
 
-      def repositories_with_proxy(proxy_id)
-        root_repos = RootRepository.with_selected_proxy(proxy_id)
-
-        if self == HttpProxy.default_global_content_proxy
-          root_repos += RootRepository.with_global_proxy
-        end
-
-        root_repos
-      end
-
-      def remove_references_to_proxy
-        root_repos = repositories_with_proxy(nil).uniq.sort
-
-        setting = Setting.find_by(name: 'content_default_http_proxy')
-        if setting&.value && setting.value == self.name
-          setting.update_attribute(:value, '')
-        end
-
-        unless root_repos.empty?
-          ForemanTasks.async_task(
-            ::Actions::BulkAction,
-            ::Actions::Katello::Repository::Update,
-            root_repos,
-            http_proxy_policy: Katello::RootRepository::GLOBAL_DEFAULT_HTTP_PROXY,
-            http_proxy_id: nil)
-        end
-      end
-
       def update_default_proxy_setting
         changes = self.previous_changes
         if changes.key?(:name)
@@ -61,7 +32,13 @@ module Katello
         changes = self.previous_changes
         if changes.key?(:url) || changes.key?(:username) || changes.key?(:password)
 
-          repos = repositories_with_proxy(id).uniq.collect(&:library_instance)
+          root_repos = RootRepository.with_selected_proxy(id)
+
+          if self == HttpProxy.default_global_content_proxy
+            root_repos += RootRepository.with_global_proxy
+          end
+
+          repos = root_repos.uniq.collect(&:library_instance)
 
           unless repos.empty?
             ForemanTasks.async_task(

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

@@ -37,6 +37,7 @@ module Katello
 
         attr_accessor :statistics
 
+        scope :with_upstream_pools, -> { joins(:pools).merge(Katello::Pool.upstream).distinct }
         scope :having_name_or_label, ->(name_or_label) { where("name = :id or label = :id", :id => name_or_label) }
         scoped_search :on => :label, :complete_value => :true
 
@@ -69,6 +70,10 @@ module Katello
           self.providers.redhat.first
         end
 
+        def redhat_account_number
+          pools.upstream.pluck(:account_number).first
+        end
+
         def active_pools_count
           self.pools.where.not(:unmapped_guest => true).count
         end
@@ -118,6 +123,10 @@ module Katello
           end
         end
 
+        def clear_manifest_expired_notifications
+          NotificationBlueprint.find_by(name: 'manifest_expired_warning').notifications.where(:subject => self).destroy_all
+        end
+
         def redhat_repository_url
           redhat_provider.repository_url
         end

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

@@ -43,6 +43,10 @@ module Katello
         self::CONTENT_TYPE
       end
 
+      def backend_identifier_field
+        nil
+      end
+
       def content_unit_class
         "::Katello::Pulp::#{self.name.demodulize}".constantize
       end
@@ -101,7 +105,7 @@ module Katello
       end
 
       def import_for_repository(repository)
-        pulp_ids = []
+        pulp_id_href_map = {}
         service_class = SmartProxy.pulp_master!.content_service(content_type)
         fetch_only_ids = !repository.content_view.default? &&
                          !repository.repository_type.unique_content_per_repo
@@ -110,6 +114,7 @@ module Katello
           units.each do |unit|
             unit = unit.with_indifferent_access
             pulp_id = unit[service_class.unit_identifier]
+            backend_identifier = unit.dig(service_class.backend_unit_identifier)
             unless fetch_only_ids
               model = Katello::Util::Support.active_record_retry do
                 self.where(:pulp_id => pulp_id).first_or_create
@@ -119,41 +124,34 @@ module Katello
               model.repository_id = repository.id unless many_repository_associations
               service.update_model(model)
             end
-            pulp_ids << pulp_id
+            pulp_id_href_map[pulp_id] = backend_identifier
           end
         end
-        sync_repository_associations(repository, :pulp_ids => pulp_ids) if self.many_repository_associations
+        sync_repository_associations(repository, :pulp_id_href_map => pulp_id_href_map) if self.many_repository_associations
       end
 
       def sync_repository_associations(repository, options = {})
         additive = options.fetch(:additive, false)
-        pulp_ids = options.fetch(:pulp_ids, nil)
-        associated_ids = with_pulp_id(pulp_ids).pluck(:id) if pulp_ids
-
-        table_name = self.repository_association_class.table_name
-        attribute_name = unit_id_field
+        pulp_id_href_map = options.dig(:pulp_id_href_map) || {}
+        pulp_ids = options.dig(:pulp_ids) || pulp_id_href_map.try(:keys)
+        ids_for_repository = with_pulp_id(pulp_ids).pluck(:id, :pulp_id)
+        associated_ids = ids_for_repository.map(&:first)
+        id_href_map_for_repository = {}
+        ids_for_repository.each { |id_href| id_href_map_for_repository[id_href[0]] = id_href[1] }
+        id_href_map_for_repository.each_pair { |k, v| id_href_map_for_repository[k] = pulp_id_href_map[v] }
 
         existing_ids = self.repository_association_class.uncached do
-          self.repository_association_class.where(:repository_id => repository).pluck(attribute_name)
-        end
-        new_ids = associated_ids - existing_ids
-        delete_ids = existing_ids - associated_ids
-
-        queries = []
-
-        if delete_ids.any? && !additive
-          queries << "DELETE FROM #{table_name} WHERE repository_id=#{repository.id} AND #{attribute_name} IN (#{delete_ids.join(', ')})"
-        end
-
-        unless new_ids.empty?
-          inserts = new_ids.map { |unit_id| "(#{unit_id.to_i}, #{repository.id.to_i}, '#{Time.now.utc.to_s(:db)}', '#{Time.now.utc.to_s(:db)}')" }
-          queries << "INSERT INTO #{table_name} (#{attribute_name}, repository_id, created_at, updated_at) VALUES #{inserts.join(', ')}"
+          self.repository_association_class.where(:repository_id => repository).pluck(unit_id_field)
         end
 
         ActiveRecord::Base.transaction do
-          queries.each do |query|
+          if !additive && (delete_ids = existing_ids - associated_ids).any?
+            query = "DELETE FROM #{self.repository_association_class.table_name} WHERE repository_id=#{repository.id} AND #{unit_id_field} IN (#{delete_ids.join(', ')})"
             ActiveRecord::Base.connection.execute(query)
           end
+          unless (new_ids = associated_ids - existing_ids).empty?
+            self.repository_association_class.import(db_columns_sync, db_values(new_ids, id_href_map_for_repository, repository), validate: false)
+          end
         end
       end
 
@@ -161,29 +159,58 @@ module Katello
         if many_repository_associations
           delete_query = "delete from #{repository_association_class.table_name} where repository_id = #{dest_repo.id} and
                          #{unit_id_field} not in (select #{unit_id_field} from #{repository_association_class.table_name} where repository_id = #{source_repo.id})"
-
-          insert_query = "insert into #{repository_association_class.table_name} (repository_id, #{unit_id_field})
-                          select #{dest_repo.id} as repository_id, #{unit_id_field} from #{repository_association_class.table_name}
-                          where repository_id = #{source_repo.id} and #{unit_id_field} not in (select #{unit_id_field}
-                          from #{repository_association_class.table_name} where repository_id = #{dest_repo.id})"
+          ActiveRecord::Base.transaction do
+            ActiveRecord::Base.connection.execute(delete_query)
+            self.repository_association_class.import(db_columns_copy, db_values_copy(source_repo, dest_repo), validate: false)
+          end
         else
           columns = column_names - ["id", "pulp_id", "created_at", "updated_at", "repository_id"]
-
-          delete_query = "delete from #{self.table_name} where repository_id = #{dest_repo.id} and
+          queries = []
+          queries << "delete from #{self.table_name} where repository_id = #{dest_repo.id} and
                           pulp_id not in (select pulp_id from #{self.table_name} where repository_id = #{source_repo.id})"
-          insert_query = "insert into #{self.table_name} (repository_id, pulp_id, #{columns.join(',')})
+          queries << "insert into #{self.table_name} (repository_id, pulp_id, #{columns.join(',')})
                     select #{dest_repo.id} as repository_id, pulp_id, #{columns.join(',')} from #{self.table_name}
                     where repository_id = #{source_repo.id} and pulp_id not in (select pulp_id
                     from #{self.table_name} where repository_id = #{dest_repo.id})"
-
+          ActiveRecord::Base.transaction do
+            queries.each do |query|
+              ActiveRecord::Base.connection.execute(query)
+            end
+          end
         end
-        ActiveRecord::Base.connection.execute(delete_query)
-        ActiveRecord::Base.connection.execute(insert_query)
       end
 
       def with_pulp_id(unit_pulp_ids)
         where('pulp_id in (?)', unit_pulp_ids)
       end
+
+      def db_columns_sync
+        [unit_id_field, backend_identifier_field, :repository_id, :created_at, :updated_at].compact
+      end
+
+      def db_columns_copy
+        [unit_id_field, backend_identifier_field, :repository_id].compact
+      end
+
+      def db_values_copy(source_repo, dest_repo)
+        db_values = []
+        existing_unit_ids = self.repository_association_class.where(repository: dest_repo).pluck(unit_id_field)
+        if existing_unit_ids.empty?
+          new_units = self.repository_association_class.where(repository: source_repo)
+        else
+          new_units = self.repository_association_class.where(repository: source_repo).where.not("#{unit_id_field} in (?) ", existing_unit_ids)
+        end
+        unit_backend_identifier_field = backend_identifier_field
+        unit_identifier_filed = unit_id_field
+        new_units.each do |unit|
+          db_values << [unit[unit_identifier_filed], unit[unit_backend_identifier_field], dest_repo.id].compact
+        end
+        db_values
+      end
+
+      def db_values(new_ids, pulp_id_href_map, repository)
+        new_ids.map { |unit_id| [unit_id.to_i, pulp_id_href_map.dig(unit_id), repository.id.to_i, Time.now.utc.to_s(:db), Time.now.utc.to_s(:db)].compact }
+      end
     end
   end
 end