katello 3.13.4 → 3.14.0.rc1

data/app/models/katello/content_view_filter.rb

@@ -5,9 +5,10 @@ module Katello
     RPM = Rpm::CONTENT_TYPE
     PACKAGE_GROUP   = PackageGroup::CONTENT_TYPE
     ERRATA          = Erratum::CONTENT_TYPE
+    MODULE_STREAM   = ModuleStream::CONTENT_TYPE
     DEB             = Deb::CONTENT_TYPE
-    CONTENT_TYPES   = [RPM, PACKAGE_GROUP, ERRATA, DOCKER, DEB].freeze
-    CONTENT_OPTIONS = { _('Packages') => RPM, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Container Images') => DOCKER, _('deb Packages') => DEB }.freeze
+    CONTENT_TYPES   = [RPM, PACKAGE_GROUP, ERRATA, DOCKER, DEB, MODULE_STREAM].freeze
+    CONTENT_OPTIONS = { _('Packages') => RPM, _('Module Streams') => ModuleStream, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Container Images') => DOCKER, _('deb Packages') => DEB }.freeze
 
     belongs_to :content_view,
                :class_name => "Katello::ContentView",
@@ -31,13 +32,17 @@ module Katello
                   :complete_value => {Rpm::CONTENT_TYPE.to_sym => "Katello::ContentViewPackageFilter",
                                       PackageGroup::CONTENT_TYPE.to_sym => "Katello::ContentViewPackageGroupFilter",
                                       Erratum::CONTENT_TYPE.to_sym => "Katello::ContentViewErratumFilter",
-                                      DOCKER.to_sym => "Katello::ContentViewDockerFilter"}
+                                      DOCKER.to_sym => "Katello::ContentViewDockerFilter",
+                                      MODULE_STREAM.to_sym => "Katello::ContentViewModuleStreamFilter"}
     scoped_search :on => :inclusion, :rename => :inclusion_type, :complete_value => {:include => true, :exclude => :false}
 
-    def self.yum
-      where(:type => [::Katello::ContentViewPackageGroupFilter.name,
-                      ::Katello::ContentViewErratumFilter.name,
-                      ::Katello::ContentViewPackageFilter.name])
+    def self.yum(include_module_streams = true)
+      types = [::Katello::ContentViewPackageGroupFilter.name,
+               ::Katello::ContentViewErratumFilter.name,
+               ::Katello::ContentViewPackageFilter.name
+              ]
+      types << ::Katello::ContentViewModuleStreamFilter.name if include_module_streams
+      where(:type => types)
     end
 
     def self.deb
@@ -49,6 +54,14 @@ module Katello
       where(:type => [::Katello::ContentViewDockerFilter.name])
     end
 
+    def self.module_stream
+      where(:type => ::Katello::ContentViewModuleStreamFilter.name)
+    end
+
+    def self.errata
+      where(:type => ::Katello::ContentViewErratumFilter.name)
+    end
+
     def params_format
       {}
     end
@@ -58,7 +71,8 @@ module Katello
         ContentViewPackageFilter => RPM,
         ContentViewErratumFilter => ERRATA,
         ContentViewPackageGroupFilter => PACKAGE_GROUP,
-        ContentViewDockerFilter => DOCKER
+        ContentViewDockerFilter => DOCKER,
+        ContentViewModuleStreamFilter => MODULE_STREAM
       }[self.class]
     end
 
@@ -72,6 +86,8 @@ module Katello
         ContentViewErratumFilter
       when DOCKER
         ContentViewDockerFilter
+      when MODULE_STREAM
+        ContentViewModuleStreamFilter
       else
         fail _("Invalid content type '%{content_type}' provided. Content types can be one of %{content_types}") %
                  { :content_type => content_type, :content_types => CONTENT_TYPES.join(", ") }
@@ -86,6 +102,8 @@ module Katello
         ContentViewPackageGroupFilterRule
       when ContentViewErratumFilter.name
         ContentViewErratumFilterRule
+      when ContentViewModuleStreamFilter.name
+        ContentViewModuleStreamFilterRule
       when ContentViewDockerFilter.name
         ContentViewDockerFilterRule
       else
@@ -102,6 +120,8 @@ module Katello
         filter.package_group_rule_ids
       when ContentViewErratumFilter.name
         filter.erratum_rule_ids
+      when ContentViewModuleStreamFilter.name
+        filter.module_stream_ids
       when ContentViewDockerFilter.name
         filter.docker_rule_ids
       else

data/app/models/katello/content_view_module_stream_filter.rb

@@ -0,0 +1,14 @@
+module Katello
+  class ContentViewModuleStreamFilter < ContentViewFilter
+    CONTENT_TYPE = ModuleStream::CONTENT_TYPE
+    has_many :module_stream_rules, :dependent => :destroy, :foreign_key => :content_view_filter_id,
+                             :class_name => "Katello::ContentViewModuleStreamFilterRule"
+
+    validates_lengths_from_database
+
+    def generate_clauses(_repo)
+      return if module_stream_rules.blank?
+      module_stream_rules.map(&:module_stream_id)
+    end
+  end
+end

data/app/models/katello/content_view_module_stream_filter_rule.rb

@@ -0,0 +1,11 @@
+module Katello
+  class ContentViewModuleStreamFilterRule < Katello::Model
+    include ::Katello::Concerns::ContentViewFilterRuleCommon
+    belongs_to :filter,
+               :class_name => "Katello::ContentViewModuleStreamFilter",
+               :inverse_of => :module_stream_rules,
+               :foreign_key => :content_view_filter_id
+    belongs_to :module_stream, :class_name => "Katello::ModuleStream", :inverse_of => :rules
+    validates :module_stream_id, :presence => true, :uniqueness => { :scope => :content_view_filter_id }
+  end
+end

data/app/models/katello/content_view_package_filter.rb

@@ -20,29 +20,39 @@ module Katello
       if self.original_packages
         package_filenames.concat(repo.packages_without_errata.map(&:filename))
       end
-
-      { 'filename' => { "$in" => package_filenames } } unless package_filenames.empty?
+      ContentViewPackageFilter.generate_rpm_clauses(package_filenames)
     end
 
     def original_packages=(value)
       self[:original_packages] = value
     end
 
-    protected
+    def self.generate_rpm_clauses(package_filenames = [])
+      { 'filename' => { "$in" => package_filenames } } unless package_filenames.empty?
+    end
+
+    def applicable_rpms
+      Rpm.in_repositories(self.applicable_repos)
+    end
 
     def query_rpms(repo, rule)
+      rpms = Rpm.in_repositories(repo)
+      query_rpms_from_collection(rpms, rule).pluck("#{Rpm.table_name}.filename")
+    end
+
+    def query_rpms_from_collection(collection, rule)
       query_name = rule.name.tr("*", "%")
-      query = Rpm.in_repositories(repo).non_modular.where("#{Rpm.table_name}.name ilike ?", query_name)
-      if rule.architecture
+      query = collection.non_modular.where("#{Rpm.table_name}.name ilike ?", query_name)
+      if rule.architecture.present?
         query_arch = rule.architecture.tr("*", "%")
         query = query.where("#{Rpm.table_name}.arch ilike ?", query_arch)
       end
-      if !rule.version.blank?
+      if rule.version.present?
         query = query.search_version_equal(rule.version)
-      elsif !rule.min_version.blank? || !rule.max_version.blank?
+      elsif rule.min_version.present? || rule.max_version.present?
         query = query.search_version_range(rule.min_version, rule.max_version)
       end
-      query.pluck("#{Rpm.table_name}.filename")
+      query.default_sort
     end
   end
 end

data/app/models/katello/content_view_version.rb

@@ -253,6 +253,10 @@ module Katello
       library_packages.where.not(:id => packages)
     end
 
+    def srpms
+      Katello::Srpm.in_repositories(self.repositories)
+    end
+
     def srpm_count
       Katello::Srpm.in_repositories(self.repositories.archived).count
     end
@@ -294,11 +298,12 @@ module Katello
     end
 
     def docker_tag_count
-      ::Katello::DockerMetaTag.where(:repository_id => repositories.archived.docker_type).count
+      docker_tags.count
     end
 
     def docker_tags
-      ::Katello::DockerMetaTag.where(:repository_id => repositories.docker_type)
+      # Don't count tags from non-archived repos; this causes count errors
+      ::Katello::DockerMetaTag.where(:id => RepositoryDockerMetaTag.where(:repository_id => repositories.archived.docker_type).select(:docker_meta_tag_id))
     end
 
     def debs

data/app/models/katello/deb.rb

@@ -3,10 +3,6 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     CONTENT_TYPE = Pulp::Deb::CONTENT_TYPE
-
-    has_many :repositories, :through => :repository_debs, :class_name => "Katello::Repository"
-    has_many :repository_debs, :class_name => "Katello::RepositoryDeb", :dependent => :destroy, :inverse_of => :deb
-
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version, :complete_value => true
     scoped_search :on => :architecture, :complete_value => true
@@ -19,10 +15,6 @@ module Katello
       order(:name).order(:version).order(:architecture)
     end
 
-    def self.repository_association_class
-      RepositoryDeb
-    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

data/app/models/katello/docker_manifest.rb

@@ -2,10 +2,6 @@ module Katello
   class DockerManifest < Katello::Model
     include Concerns::PulpDatabaseUnit
     has_many :docker_tags, :as => :docker_taggable, :class_name => "Katello::DockerTag", :dependent => :destroy
-    has_many :repository_docker_manifests, :class_name => "Katello::RepositoryDockerManifest",
-             :dependent => :destroy, :inverse_of => :docker_manifest
-    has_many :repositories, :through => :repository_docker_manifests, :inverse_of => :docker_manifests
-
     has_many :docker_manifest_list_manifests, :class_name => "Katello::DockerManifestListManifest",
              :dependent => :delete_all, :inverse_of => :docker_manifest
     has_many :docker_manifest_lists, :through => :docker_manifest_list_manifests, :inverse_of => :docker_manifests
@@ -17,10 +13,6 @@ module Katello
     scoped_search :on => :schema_version, :rename => :schema_version, :complete_value => true, :only_explicit => true
     scoped_search :relation => :docker_manifest_lists, :on => :digest, :rename => :manifest_list_digest, :complete_value => true, :only_explicit => true
 
-    def self.repository_association_class
-      RepositoryDockerManifest
-    end
-
     def self.default_sort
       order(:schema_version)
     end

data/app/models/katello/docker_manifest_list.rb

@@ -3,10 +3,6 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     has_many :docker_tags, :as => :docker_taggable, :class_name => "Katello::DockerTag", :dependent => :destroy
-    has_many :repository_docker_manifest_lists, :class_name => "Katello::RepositoryDockerManifestList",
-             :dependent => :destroy, :inverse_of => :docker_manifest_list
-    has_many :repositories, :through => :repository_docker_manifest_lists, :inverse_of => :docker_manifest_lists
-
     has_many :docker_manifest_list_manifests, :class_name => "Katello::DockerManifestListManifest",
              :dependent => :delete_all, :inverse_of => :docker_manifest_list
     has_many :docker_manifests, :through => :docker_manifest_list_manifests, :inverse_of => :docker_manifest_lists
@@ -17,10 +13,6 @@ module Katello
     scoped_search :on => :digest, :rename => :digest, :complete_value => true, :only_explicit => true
     scoped_search :on => :schema_version, :rename => :schema_version, :complete_value => true, :only_explicit => true
 
-    def self.repository_association_class
-      RepositoryDockerManifestList
-    end
-
     def self.default_sort
       order(:schema_version)
     end

data/app/models/katello/docker_meta_tag.rb

@@ -2,8 +2,9 @@ module Katello
   class DockerMetaTag < Katello::Model
     include ScopedSearchExtensions
 
-    belongs_to :repository, :inverse_of => :docker_meta_tags, :class_name => "Katello::Repository"
-
+    has_many :repository_docker_meta_tags, :class_name => "Katello::RepositoryDockerMetaTag", :dependent => :delete_all, :inverse_of => :docker_meta_tag
+    has_many :repositories, :through => :repository_docker_meta_tags, :inverse_of => :docker_meta_tags
+    has_many :root_repositories, through: :repositories, :source => :root, class_name: "Katello::RootRepository"
     belongs_to :schema1, :class_name => "Katello::DockerTag",
                           :inverse_of => :schema1_meta_tag
 
@@ -19,12 +20,20 @@ module Katello
                   :complete_value => true, :only_explicit => true
     scoped_search :on => :digest, :rename => :digest, :complete_value => false,
                   :only_explicit => true, :ext_method => :find_by_digest, :operators => ["="]
-    scoped_search :relation => :repositories, :on => :name, :rename => :repository, :complete_value => true,
+    scoped_search :relation => :root_repositories, :on => :name, :rename => :repository, :complete_value => true,
                   :ext_method => :search_by_repo_name, :only_explicit => true
 
+    def self.repository_association_class
+      RepositoryDockerMetaTag
+    end
+
+    def repository
+      repositories.first
+    end
+
     def self.search_by_repo_name(_key, operator, value)
       conditions = sanitize_sql_for_conditions(["#{Katello::RootRepository.table_name}.name #{operator} ?", value_to_sql(operator, value)])
-      query = self.joins(:repository => :root).where(conditions).select('id')
+      query = self.joins(:repositories => :root).where(conditions).select('id')
       {:conditions => "#{self.table_name}.id IN (#{query.to_sql})"}
     end
 
@@ -79,25 +88,29 @@ module Katello
     delegate_to_tags :docker_manifest
     delegate_to_tags :product, :environment, :content_view_version
 
-    def repositories
-      [self.repository]
-    end
-
     def related_tags
-      self.class.where(:repository_id => repository.group, :name => name)
+      self.class.where(:id => ::Katello::RepositoryDockerMetaTag.where(:repository_id => repositories.first.group).
+                       select(:docker_meta_tag_id), :name => name)
     end
 
     def self.in_repositories(repos, grouped = false)
       if grouped
-        search_in_tags(DockerTag.in_repositories(repos).grouped)
+        search_in_tags(DockerTag.in_repositories(repos), grouped)
       else
-        search_in_tags(DockerTag.in_repositories(repos))
+        search_in_tags(DockerTag.in_repositories(repos)).where(:id => repository_association_class.where(:repository_id => repos).select(:docker_meta_tag_id))
       end
     end
 
-    def self.search_in_tags(tags)
+    def self.search_in_tags(tags, grouped = false)
       sql = tags.select("#{::Katello::DockerTag.table_name}.id").to_sql
-      self.where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
+
+      if grouped
+        grouped_fields = "#{table_name}.name, katello_repositories.root_id"
+        ids = distinct.select("ON (#{grouped_fields}) #{table_name}.id").joins(:repositories)
+        where(:id => ids).where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
+      else
+        self.where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
+      end
     end
 
     def schema1_manifest
@@ -123,7 +136,7 @@ module Katello
     def self.import_meta_tags(repositories)
       repositories.each do |repo|
         tag_table_values = get_tag_table_values(repo)
-        meta_tag_table_values = DockerMetaTag.where(:repository => repo).
+        meta_tag_table_values = DockerMetaTag.where(:id => repository_association_class.where(:repository_id => repo.id).select(:docker_meta_tag_id)).
                                   select(:schema1_id, :schema2_id, :name).map do |meta_tag|
           [meta_tag.schema1_id, meta_tag.schema2_id, meta_tag.name]
         end
@@ -140,22 +153,27 @@ module Katello
         end
 
         unless params_to_query_for_delete.empty?
-          ::Katello::DockerMetaTag.where(:repository => repo).
-                                   where(params_to_query_for_delete.join(" OR ")).delete_all
+          DockerMetaTag.where(:id => repository_association_class.
+                              where(:repository_id => repo.id).
+                              select(:docker_meta_tag_id)).
+                              where(params_to_query_for_delete.join(" OR ")).delete_all
         end
 
+        metatags = []
         (tag_table_values - meta_tag_table_values).each do |schema1, schema2, name|
-          DockerMetaTag.where(:schema1_id => schema1,
+          metatags << DockerMetaTag.where(:schema1_id => schema1,
                               :schema2_id => schema2,
-                              :name => name,
-                              :repository => repo).create!
+                              :name => name).create!
         end
+        repo.docker_meta_tags += metatags
       end
     end
 
     def self.get_tag_table_values(repo)
       # queries DockerTags for a repo and retuns a [schema1, schema2 , name] tuple combination
-      tags = ::Katello::DockerTag.where(:repository_id => repo.id)
+      tags = ::Katello::DockerTag.where(:id => RepositoryDockerTag.
+                                        where(:repository_id => repo.id).
+                                        select(:docker_tag_id))
       dups = tags.group_by(&:name)
 
       dups.map do |name, values|

data/app/models/katello/docker_tag.rb

@@ -6,8 +6,6 @@ module Katello
     CONTENT_TYPE = 'docker_tag'.freeze
 
     belongs_to :docker_taggable, :polymorphic => true, :inverse_of => :docker_tags
-    belongs_to :repository, :inverse_of => :docker_tags, :class_name => "Katello::Repository"
-
     has_one :schema1_meta_tag, :class_name => "Katello::DockerMetaTag", :foreign_key => "schema1_id",
                                :inverse_of => :schema1, :dependent => :nullify
 
@@ -16,7 +14,25 @@ module Katello
 
     before_destroy :cleanup_meta_tags
 
-    delegate :relative_path, :environment, :content_view_version, :product, :to => :repository
+    def repository
+      repositories.first
+    end
+
+    def relative_path
+      repositories.first.relative_path
+    end
+
+    def environment
+      repositories.first.environment
+    end
+
+    def content_view_version
+      repositories.first.content_view_version
+    end
+
+    def product
+      repositories.first.product
+    end
 
     def associated_meta_tag
       schema1_meta_tag || schema2_meta_tag
@@ -42,42 +58,15 @@ module Katello
       docker_taggable_id
     end
 
-    def self.grouped
-      grouped_fields = "#{table_name}.name, #{Repository.table_name}.root_id, #{Product.table_name}.name"
-      ids = distinct.select("ON (#{grouped_fields}) #{table_name}.id").joins(:repository => :product)
-      where(:id => ids)
-    end
-
     def self.import_for_repository(repository)
-      self.where(:repository_id => repository).destroy_all
       super(repository)
-      pulp_ids = self.where(:repository_id => repository.id).pluck(:pulp_id)
-      import_all(pulp_ids) unless pulp_ids.blank?
-    end
-
-    def self.import_all(pulp_ids = nil)
-      self.destroy_all if pulp_ids.blank?
-      self.where(:repository_id => nil).destroy_all
-      if pulp_ids
-        repos = ::Katello::Repository.joins(:docker_tags).where("katello_docker_tags.pulp_id" => pulp_ids).distinct
-        ::Katello::DockerMetaTag.import_meta_tags(repos)
-      else
-        ::Katello::DockerMetaTag.import_meta_tags(::Katello::Repository.docker_type)
-      end
-    end
-
-    def self.many_repository_associations
-      false
-    end
-
-    # docker tag only has one repo
-    def repositories
-      [repository]
+      ::Katello::DockerMetaTag.import_meta_tags([repository])
     end
 
     def related_tags
       # tags in the same repo group with the same name
-      self.class.where(:repository_id => repository.group, :name => name)
+      self.class.where(:id => RepositoryDockerTag.where(:repository_id => repositories.first.group).select(:docker_tag_id),
+                       :name => name)
     end
 
     def self.with_identifiers(ids)