katello 3.13.4 → 3.14.0.rc1

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

@@ -183,15 +183,6 @@ module Katello
             end
           end
 
-          def events(uuid)
-            response = Candlepin::CandlepinResource.get(join_path(path(uuid), 'events'), self.default_headers).body
-            if response.present?
-              ::Katello::Util::Data.array_with_indifferent_access JSON.parse(response)
-            else
-              return []
-            end
-          end
-
           def content_overrides(id)
             result = Candlepin::CandlepinResource.get(join_path(path(id), 'content_overrides'), self.default_headers).body
             ::Katello::Util::Data.array_with_indifferent_access(JSON.parse(result))

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

@@ -101,11 +101,6 @@ module Katello
             OpenSSL::PKCS12.create(password, name, p, c, nil, "PBE-SHA1-3DES", "PBE-SHA1-3DES")
           end
 
-          def events(key)
-            response = self.get(join_path(path(key), 'events'), self.default_headers).body
-            ::Katello::Util::Data.array_with_indifferent_access JSON.parse(response)
-          end
-
           def service_levels(uuid)
             response = Candlepin::CandlepinResource.get(join_path(path(uuid), 'servicelevels'), self.default_headers).body
             if response.empty?

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

@@ -72,12 +72,8 @@ module Katello
 
           def create_unlimited_subscription(owner_key, product_id, start_date)
             start_date ||= Time.now
-
-            # Subscription-manager (python-rhsm) can't read the certificate with end date beyond
-            # 2049 year correctly. Refer the links below for more details:
-            # https://bugzilla.redhat.com/show_bug.cgi?id=1789654
-            # https://github.com/candlepin/candlepin/blob/5b87865f304555c112982af4fbc83a1c463d37b2/server/src/main/java/org/candlepin/model/UeberCertificateGenerator.java#L247
-            end_date = Time.parse('2049-12-01 00:00:00 +0000')
+            # End it 100 years from now
+            end_date ||= start_date + 10_950.days
 
             pool = {
               'startDate' => start_date,

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

@@ -12,22 +12,37 @@ module Katello
 
         def self.get(path, headers = {:accept => :json})
           logger.debug "Sending GET request to Registry: #{path}"
-          client = RegistryResource.rest_client(Net::HTTP::Get, :get, path)
+          client = RegistryResource.load_class.rest_client(Net::HTTP::Get, :get, path)
           client.get(headers)
         end
       end
 
       class RegistryResource < HttpResource
-        if SETTINGS[:katello][:container_image_registry]
-          cfg = SETTINGS[:katello][:container_image_registry]
-          url = cfg[:crane_url]
-          uri = URI.parse(url)
-          self.prefix = uri.path
-          self.site = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-          self.ca_cert_file = cfg[:crane_ca_cert_file]
-        end
-
         class << self
+          def load_class
+            container_config = SETTINGS.dig(:katello, :container_image_registry)
+            registry_url = nil
+            pulp_master = ::SmartProxy.pulp_master
+
+            # Pulp 3 has its own registry
+            if pulp_master && pulp_master.pulp3_repository_type_support?(::Katello::Repository::DOCKER_TYPE)
+              registry_url = pulp_master.setting('Pulp3', 'content_app_url')
+              # Assume the registry uses the same CA as the Smart Proxy
+              ca_cert_file = Setting[:ssl_ca_file]
+            elsif container_config
+              registry_url = container_config[:crane_url]
+              ca_cert_file = container_config[:registry_ca_cert_file]
+            end
+
+            fail Errors::ContainerRegistryNotConfigured unless registry_url
+
+            uri = URI.parse(registry_url)
+            self.prefix = uri.path
+            self.site = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+            self.ca_cert_file = ca_cert_file
+            self
+          end
+
           def process_response(response)
             debug_level = response.code >= 400 ? :error : :debug
             logger.send(debug_level, "Registry request returned with code #{response.code}")

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

@@ -54,7 +54,7 @@ module Katello
         filters = fetch_filters.send(list_type).where(:id => @filters) # abstract
         if filters.any?
           # generate the clauses from filters to be implemented by subclasses
-          clauses = collect_clauses(@repo, filters) # abstract
+          clauses = collect_clauses(@repo, filters) || [] # abstract
           clauses.delete_if { |cls| cls.blank? }
           if clauses.any?
             clauses

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

@@ -0,0 +1,49 @@
+module Katello
+  module Util
+    class ModuleStreamClauseGenerator
+      include Util::FilterClauseGenerator
+
+      protected
+
+      def fetch_filters
+        ContentViewFilter.module_stream.or(ContentViewFilter.errata)
+      end
+
+      def whitelist_non_matcher_clause
+        {"_id" => {"$not" => {"$exists" => true}}}
+      end
+
+      def whitelist_all_matcher_clause
+        {"_id" => {"$exists" => true}}
+      end
+
+      def collect_clauses(repo, filters)
+        [ContentViewErratumFilter, ContentViewModuleStreamFilter].collect do |filter_class|
+          content_type_filters = filters.where(:type => filter_class.to_s)
+          make_module_stream_clauses(repo, content_type_filters) unless content_type_filters.empty?
+        end
+      end
+
+      def make_module_stream_clauses(repo, filters)
+        content_type = filters.first.content_type
+        clauses = filters.collect do |filter|
+          filter.generate_clauses(repo)
+        end
+        clauses.flatten!
+        clauses.compact!
+        module_stream_clauses_from_content(content_type, clauses) unless clauses.empty?
+      end
+
+      def module_stream_clauses_from_content(content_type, clauses)
+        module_streams = []
+        case content_type
+        when ContentViewFilter::ERRATA
+          module_streams = Katello::Erratum.list_modular_streams_by_clauses(@repo, clauses)
+        when ContentViewFilter::MODULE_STREAM
+          module_streams = ModuleStream.where(:id => clauses)
+        end
+        {'_id' => { "$in" => module_streams.pluck(:pulp_id)}} unless module_streams.empty?
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Katello
       protected
 
       def fetch_filters
-        ContentViewFilter.yum
+        ContentViewFilter.yum(false)
       end
 
       def collect_clauses(repo, filters)

data/app/models/katello/ansible_collection.rb

@@ -3,24 +3,21 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     self.table_name = 'katello_ansible_collections'
-
     CONTENT_TYPE = 'ansible collection'.freeze
 
-    has_many :repository_ansible_collections, :class_name => "Katello::RepositoryAnsibleCollection", :dependent => :destroy, :inverse_of => :ansible_collection, :foreign_key => :ansible_collection_id
-    has_many :repositories, :through => :repository_ansible_collections, :class_name => "Katello::Repository"
+    has_many :ansible_collection_tags, :class_name => "Katello::AnsibleCollectionTag", :dependent => :delete_all
+    has_many :tags, :through => :ansible_collection_tags
 
     scoped_search :on => :name, :complete_value => true
-    scoped_search :on => :namespace, :complete_value => true
+    scoped_search :on => :namespace, :complete_value => true, :rename => :author
     scoped_search :on => :version, :complete_value => true
+    scoped_search :on => :checksum, :complete_value => true
+    scoped_search :on => :name, :complete_value => true, :relation => :tags, :rename => :tag
 
     def self.default_sort
       order(:name)
     end
 
-    def self.repository_association_class
-      RepositoryAnsibleCollection
-    end
-
     def self.unit_id_field
       'ansible_collection_id'
     end

data/app/models/katello/ansible_collection_tag.rb

@@ -0,0 +1,8 @@
+module Katello
+  class AnsibleCollectionTag < ApplicationRecord
+    self.table_name = 'katello_ansible_collection_tags'
+
+    belongs_to :ansible_collection, :inverse_of => :ansible_collection_tags, :class_name => 'Katello::AnsibleCollection'
+    belongs_to :tag, :inverse_of => :ansible_collection_tags, :class_name => 'Katello::AnsibleTag', :foreign_key => :ansible_tag_id
+  end
+end

data/app/models/katello/ansible_tag.rb

@@ -0,0 +1,8 @@
+module Katello
+  class AnsibleTag < ApplicationRecord
+    self.table_name = 'katello_ansible_tags'
+
+    has_many :ansible_collection_tags, :class_name => "Katello::AnsibleCollectionTag", :dependent => :delete_all
+    has_many :ansible_collections, :through => :ansible_collection_tags
+  end
+end

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

@@ -174,24 +174,24 @@ module Katello
       end
 
       def sync_package_associations(new_installed_package_ids)
-        old_associated_ids = self.installed_package_ids
-        table_name = self.host_installed_packages.table_name
+        Katello::Util::Support.active_record_retry do
+          old_associated_ids = self.reload.installed_package_ids
+          table_name = self.host_installed_packages.table_name
 
-        new_ids = new_installed_package_ids - old_associated_ids
-        delete_ids = old_associated_ids - new_installed_package_ids
+          new_ids = new_installed_package_ids - old_associated_ids
+          delete_ids = old_associated_ids - new_installed_package_ids
 
-        queries = []
+          queries = []
 
-        if delete_ids.any?
-          queries << "DELETE FROM #{table_name} WHERE host_id=#{self.id} AND installed_package_id IN (#{delete_ids.join(', ')})"
-        end
+          if delete_ids.any?
+            queries << "DELETE FROM #{table_name} WHERE host_id=#{self.id} AND installed_package_id IN (#{delete_ids.join(', ')})"
+          end
 
-        unless new_ids.empty?
-          inserts = new_ids.map { |unit_id| "(#{unit_id.to_i}, #{self.id.to_i})" }
-          queries << "INSERT INTO #{table_name} (installed_package_id, host_id) VALUES #{inserts.join(', ')}"
-        end
+          unless new_ids.empty?
+            inserts = new_ids.map { |unit_id| "(#{unit_id.to_i}, #{self.id.to_i})" }
+            queries << "INSERT INTO #{table_name} (installed_package_id, host_id) VALUES #{inserts.join(', ')}"
+          end
 
-        ActiveRecord::Base.transaction do
           queries.each do |query|
             ActiveRecord::Base.connection.execute(query)
           end
@@ -282,5 +282,7 @@ module Katello
 end
 
 class ::Host::Managed::Jail < Safemode::Jail
-  allow :content_source, :subscription_manager_configuration_url, :rhsm_organization_label
+  allow :content_source, :subscription_manager_configuration_url, :rhsm_organization_label,
+        :host_collections, :comment, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
+        :installed_packages
 end

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

@@ -3,9 +3,16 @@ require 'set'
 module Katello
   module Concerns::PulpDatabaseUnit
     extend ActiveSupport::Concern
-    include Katello::Concerns::SearchByRepositoryName
-
     #  Class.repository_association_class
+    included do
+      if many_repository_associations
+        # rubocop:disable Rails/ReflectionClassName
+        has_many repository_association.to_sym, class_name: repository_association_class_name,
+                 dependent: :delete_all, inverse_of: association_name
+        has_many :repositories, through: repository_association.to_sym, class_name: "Katello::Repository"
+        include ::Katello::Concerns::SearchByRepositoryName
+      end
+    end
 
     def backend_data
       self.class.pulp_data(pulp_id) || {}
@@ -15,7 +22,23 @@ module Katello
       self.class.repository_association_class.where(:repository_id => repo_id, self.class.unit_id_field.to_sym => self.id).delete_all
     end
 
+    def library_repositories
+      self.repositories.where(library_instance: nil)
+    end
+
     module ClassMethods
+      def association_name
+        self.name.demodulize.underscore
+      end
+
+      def repository_association_class_name
+        "::Katello::Repository#{self.name.demodulize}"
+      end
+
+      def repository_association_class
+        repository_association_class_name.constantize
+      end
+
       def content_type
         self::CONTENT_TYPE
       end
@@ -25,11 +48,11 @@ module Katello
       end
 
       def many_repository_associations
-        true
+        self != YumMetadataFile
       end
 
       def repository_association
-        repository_association_class.name.demodulize.pluralize.underscore
+        repository_association_class_name.demodulize.pluralize.underscore
       end
 
       def immutable_unit_types

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

@@ -5,7 +5,10 @@ module Katello
       include ScopedSearchExtensions
 
       included do
-        scoped_search :relation => :repositories, :on => :name, :rename => :repository, :complete_value => true, :ext_method => :search_by_repo_name, :only_explicit => true
+        has_many :root_repositories, through: :repositories, :source => :root, class_name: "Katello::RootRepository"
+        scoped_search :relation => :root_repositories, :on => :name, :rename => :repository,
+                      :complete_value => true,
+                      :ext_method => :search_by_repo_name, :only_explicit => true
       end
 
       module ClassMethods

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

@@ -83,12 +83,12 @@ module Katello
           features = [PULP_NODE_FEATURE]
           features << PULP_FEATURE if include_default
 
-          with_features(features).joins(:capsule_lifecycle_environments).
+          unscoped.with_features(features).joins(:capsule_lifecycle_environments).
               where(katello_capsule_lifecycle_environments: { lifecycle_environment_id: environment.id })
         end
 
         def self.sync_needed?(environment)
-          with_environment(environment).any?
+          unscoped.with_environment(environment).any?
         end
       end
 
@@ -117,8 +117,9 @@ module Katello
 
       def pulp3_configuration(config_class)
         config_class.new do |config|
-          config.host = pulp3_host!
-          config.scheme = 'https'
+          uri = pulp3_uri!
+          config.host = uri.host
+          config.scheme = uri.scheme
           config.username = 'admin'
           config.password = 'password'
           config.debugging = true
@@ -139,24 +140,45 @@ module Katello
       end
 
       def pulp3_support?(repository)
-        type = Katello::RepositoryTypeManager.repository_types[repository.content_type]
-        type.pulp3_plugin && self.capabilities('Pulp3').try(:include?, type.pulp3_plugin)
+        pulp3_repository_type_support?(repository.content_type)
       end
 
-      def content_pulp3_support?(content_type)
-        content_type = content_type.is_a?(String) ? content_type : content_type.model_class::CONTENT_TYPE
-        type = Katello::RepositoryTypeManager.find_repository_type content_type
-        type.pulp3_plugin && SmartProxy.pulp_master!.capabilities('Pulp3').try(:include?, type.pulp3_plugin)
+      def pulp2_preferred_for_type?(repository_type)
+        if SETTINGS[:katello][:use_pulp_2_for_content_type].nil? ||
+            SETTINGS[:katello][:use_pulp_2_for_content_type][repository_type.to_sym].nil?
+          return false
+        else
+          return SETTINGS[:katello][:use_pulp_2_for_content_type][repository_type.to_sym]
+        end
       end
 
-      def pulp3_host!
-        url = self.setting('Pulp3', 'pulp_url')
+      def pulp3_repository_type_support?(repository_type)
+        repository_type_obj = repository_type.is_a?(String) ? Katello::RepositoryTypeManager.repository_types[repository_type] : repository_type
+        fail "Cannot find repository type #{repository_type}, is it enabled?" unless repository_type_obj
+        repository_type_obj.pulp3_plugin.present? && pulp3_enabled? && self.capabilities(PULP3_FEATURE).try(:include?, repository_type_obj.pulp3_plugin) && !pulp2_preferred_for_type?(repository_type_obj.id)
+      end
+
+      def pulp3_content_support?(content_type)
+        content_type_obj = content_type.is_a?(String) ? Katello::RepositoryTypeManager.find_content_type(content_type) : content_type
+        fail "Cannot find content type #{content_type}." unless content_type_obj
+
+        found_type = Katello::RepositoryTypeManager.repository_types.values.find { |repo_type| repo_type.content_types.include?(content_type_obj) }
+        fail "Cannot find repository type for content_type #{content_type}, is it enabled?" unless found_type
+        pulp3_repository_type_support?(found_type)
+      end
+
+      def pulp3_uri!
+        url = self.setting(PULP3_FEATURE, 'pulp_url')
         fail "Cannot determine pulp3 url, check smart proxy configuration" unless url
-        URI.parse(url).host
+        URI.parse(url)
+      end
+
+      def pulp3_host!
+        pulp3_uri!.host
       end
 
       def pulp3_url(path = nil)
-        pulp_url = self.setting('Pulp3', 'pulp_url')
+        pulp_url = self.setting(PULP3_FEATURE, 'pulp_url')
         path.blank? ? pulp_url : "#{pulp_url.sub(%r|/$|, '')}/#{path.sub(%r|^/|, '')}"
       end
 
@@ -188,12 +210,8 @@ module Katello
       end
 
       def content_service(content_type)
-        if content_type.is_a?(String)
-          content_type = RepositoryTypeManager.find_content_type(content_type)
-        end
-
-        #this will rely on smart proxy capabilities when available
-        content_pulp3_support?(content_type) ? content_type.pulp3_service_class : content_type.pulp2_service_class
+        content_type = RepositoryTypeManager.find_content_type(content_type) if content_type.is_a?(String)
+        pulp3_content_support?(content_type) ? content_type.pulp3_service_class : content_type.pulp2_service_class
       end
 
       def set_default_download_policy
@@ -254,6 +272,12 @@ module Katello
         raise ::Katello::Errors::CapsuleCannotBeReached, _("%s is unreachable. %s" % [self.name, error])
       end
 
+      def ping_pulp3
+        ::Katello::Ping.pulp3_without_auth(self.pulp3_url("api/v3"))
+      rescue Errno::EHOSTUNREACH, Errno::ECONNREFUSED, RestClient::Exception => error
+        raise ::Katello::Errors::CapsuleCannotBeReached, _("%s is unreachable. %s" % [self.name, error])
+      end
+
       def verify_ueber_certs
         self.organizations.each do |org|
           Cert::Certs.verify_ueber_cert(org)

data/app/models/katello/content_view_docker_filter.rb

@@ -21,18 +21,31 @@ module Katello
       { "_id" => { "$in" => manifest_tags } } unless manifest_tags.empty?
     end
 
+    def content_unit_pulp_ids(repo)
+      manifest_tags = []
+      self.docker_rules.each do |rule|
+        manifest_tags.concat(query_manifests(repo, rule))
+      end
+
+      manifest_tags
+    end
+
     protected
 
     def fetch_tag_pulp_ids(repo, rule, manifest_klass = DockerManifest)
       query_name = rule.name.tr("*", "%")
-      tags_query = ::Katello::DockerTag.where(:repository => repo).
+      tags_query = ::Katello::DockerTag.where(:id => ::Katello::RepositoryDockerTag.
+                                              where(:repository_id => repo.id).select(:docker_tag_id)).
                                         where(:docker_taggable_type => manifest_klass.name).
                                         where("name ilike ?", query_name).
                                         select(:docker_taggable_id)
 
       query = manifest_klass.in_repositories(repo).where("id in (#{tags_query.to_sql})")
       names = query.all.collect do |manifest|
-        manifest.docker_tags.where(:repository => repo).where("name ilike ?", query_name).all.collect do |tag|
+        manifest.docker_tags.where(:id => ::Katello::RepositoryDockerTag.
+                                   where(:repository_id => repo.id).
+                                   select(:docker_tag_id)).where("name ilike ?", query_name).
+        all.collect do |tag|
           tag.pulp_id
         end
       end