katello 3.9.1 → 3.10.0.rc1

data/app/models/katello/erratum.rb

@@ -48,6 +48,10 @@ module Katello
       RepositoryErratum
     end
 
+    def self.content_facet_association_class
+      ContentFacetErratum
+    end
+
     def self.applicable_to_hosts(hosts)
       # Note: ContentFacetErrata actually holds the "Applicable Errata" to that host
       # It is not the errata "belonging" to the host. Its rather the errata that is "applicable"
@@ -88,32 +92,11 @@ module Katello
     end
 
     def self.installable_for_hosts(hosts = nil)
-      self.where(:id => ids_installable_for_hosts(hosts))
+      ApplicableContentHelper.new(Erratum).installable_for_hosts(hosts)
     end
 
     def self.ids_installable_for_hosts(hosts = nil)
-      hosts = ::Host.where(:id => hosts) if hosts && hosts.is_a?(Array)
-
-      # Main goal of this query
-      # 1) Get me the applicable errata for these set of hosts
-      # 2) Now further prune this list. Only include errata from repos that have been "enabled" on those hosts.
-      #    In other words, prune the list to only include the errate in the "bound" repositories signified by
-      #    the inner join between ContentFacetRepository and RepositoryErratum
-      query = self.joins(:content_facet_errata).
-        joins("INNER JOIN #{Katello::ContentFacetRepository.table_name} on \
-        #{Katello::ContentFacetRepository.table_name}.content_facet_id = #{Katello::ContentFacetErratum.table_name}.content_facet_id").
-        joins("INNER JOIN #{Katello::RepositoryErratum.table_name} AS host_repo_errata ON \
-          host_repo_errata.erratum_id = #{Katello::Erratum.table_name}.id AND \
-          #{Katello::ContentFacetRepository.table_name}.repository_id = host_repo_errata.repository_id")
-
-      if hosts
-        query = query.where("#{Katello::ContentFacetRepository.table_name}.content_facet_id" => hosts.joins(:content_facet)
-                                .select("#{Katello::Host::ContentFacet.table_name}.id"))
-      else
-        query = query.joins(:content_facet_errata)
-      end
-
-      query
+      installable_for_hosts(hosts).select(:id)
     end
 
     def update_from_json(json)
@@ -136,6 +119,7 @@ module Katello
         end
       end
       update_packages(json['pkglist']) unless json['pkglist'].blank?
+      update_modules(json['pkglist']) unless json['pkglist'].blank?
     end
 
     def self.list_filenames_by_clauses(repo, clauses)
@@ -149,6 +133,21 @@ module Katello
           where(statement).pluck(:filename)
     end
 
+    def module_streams
+      # return something like
+      # {module_stream => [packages]}
+      module_stream_rpms = {}
+      packages.each do |pack|
+        pack.module_streams.each do |mod|
+          module_stream_rpms[mod.module_spec_hash] ||= []
+          module_stream_rpms[mod.module_spec_hash] << pack.nvrea unless module_stream_rpms[mod.module_spec_hash].include?(pack.nvrea)
+        end
+      end
+      module_stream_rpms.map do |module_hash, nvreas|
+        module_hash.merge(:packages => nvreas)
+      end
+    end
+
     private
 
     def convert_date_if_epoch(date)
@@ -200,7 +199,7 @@ module Katello
       needed_function = lambda do
         package_hashes = json.map { |list| list['packages'] }.flatten
         package_attributes = package_hashes.map do |hash|
-          nvrea = "#{hash['name']}-#{hash['version']}-#{hash['release']}.#{hash['arch']}"
+          nvrea = Util::Package.build_nvra(hash)
           {'name' => hash['name'], 'nvrea' => nvrea, 'filename' => hash['filename']}
         end
         existing_nvreas = self.packages.pluck(:nvrea)
@@ -213,6 +212,37 @@ module Katello
       run_until(needed_function, action_function)
     end
 
+    def update_modules(json)
+      needed_function = lambda do
+        module_stream_attributes = []
+        json.each do |package_item|
+          if package_item['module']
+            module_stream = ModuleStream.where(package_item['module']).first_or_create!
+            nvreas = package_item["packages"].map { |hash| Util::Package.build_nvra(hash) }
+            module_stream_id_column = "#{ModuleStreamErratumPackage.table_name}.module_stream_id"
+            existing = ErratumPackage.joins(:module_streams).
+                                      where(module_stream_id_column => module_stream.id,
+                                            :nvrea => nvreas).pluck(:nvrea)
+
+            (nvreas - existing).each do |nvrea|
+              package = self.packages.find_by(:nvrea => nvrea)
+              module_stream_attributes << { :module_stream_id => module_stream.id,
+                                            :erratum_package_id => package.id }
+            end
+          end
+        end
+        module_stream_attributes.uniq
+      end
+
+      action_function = lambda do |needed|
+        needed.each do |msep|
+          ModuleStreamErratumPackage.create!(msep)
+        end
+      end
+
+      run_until(needed_function, action_function)
+    end
+
     class Jail < ::Safemode::Jail
       allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested
     end

data/app/models/katello/erratum_package.rb

@@ -1,5 +1,11 @@
 module Katello
   class ErratumPackage < Katello::Model
     belongs_to :erratum, :inverse_of => :packages, :class_name => 'Katello::Erratum'
+    has_many :module_stream_errata_packages, class_name: "Katello::ModuleStreamErratumPackage", dependent: :destroy, inverse_of: :erratum_package
+    has_many :module_streams, class_name: "Katello::ModuleStream", :through => :module_stream_errata_packages
+
+    def self.non_module_stream_packages
+      where.not(:id => Katello::ModuleStreamErratumPackage.select(:erratum_package_id))
+    end
   end
 end

data/app/models/katello/glue/pulp/repo.rb

@@ -2,7 +2,6 @@ module Katello
   module Glue::Pulp::Repo
     # TODO: move into submodules
     # rubocop:disable MethodLength
-    # rubocop:disable ModuleLength
     def self.included(base)
       base.send :include, LazyAccessor
       base.send :include, InstanceMethods
@@ -116,233 +115,12 @@ module Katello
         pulp_repo_facts[:content_unit_counts].values.all? { |value| value == 0 }
       end
 
-      def create_pulp_repo
-        #if we are in library, no need for an distributor, but need to sync
-        if self.environment.try(:library?)
-          importer = generate_importer
-        else
-          #if not in library, no need for sync info, but we need a distributor
-          case self.content_type
-          when Repository::YUM_TYPE
-            importer = Runcible::Models::YumImporter.new
-          when Repository::PUPPET_TYPE
-            importer = Runcible::Models::PuppetImporter.new
-          when Repository::DEB_TYPE
-            importer = Runcible::Models::DebImporter.new
-          end
-        end
-
-        distributors = generate_distributors
-
-        Katello.pulp_server.extensions.repository.create_with_importer_and_distributors(self.pulp_id,
-                                                                                        importer,
-                                                                                        distributors,
-                                                                                        :display_name => self.name)
-      rescue RestClient::ServiceUnavailable => e
-        message = _("Pulp service unavailable during creating repository '%s', please try again later.") % self.name
-        raise PulpErrors::ServiceUnavailable.new(message, e)
-      end
-
       def generate_importer(capsule = SmartProxy.default_capsule!)
-        case self.content_type
-        when Repository::YUM_TYPE
-          Runcible::Models::YumImporter.new(yum_importer_values(capsule))
-        when Repository::FILE_TYPE
-          Runcible::Models::IsoImporter.new(importer_connection_options(capsule).merge(:feed => importer_feed_url(capsule)))
-        when Repository::PUPPET_TYPE
-          Runcible::Models::PuppetImporter.new(puppet_importer_values(capsule))
-        when Repository::DOCKER_TYPE
-          options = {}
-          options[:upstream_name] = capsule.default_capsule? ? self.docker_upstream_name : self.container_repository_name
-          options[:feed] = docker_feed_url(capsule)
-          options[:enable_v1] = false
-          options[:tags] = capsule.default_capsule? ? self.docker_tags_whitelist : nil
-          Runcible::Models::DockerImporter.new(importer_connection_options(capsule).merge(options))
-        when Repository::OSTREE_TYPE
-          options = importer_connection_options(capsule)
-          options[:depth] = capsule.default_capsule? ? root.compute_ostree_upstream_sync_depth : ostree_capsule_sync_depth
-          options[:feed] = self.importer_feed_url(capsule)
-          Runcible::Models::OstreeImporter.new(options)
-        when Repository::DEB_TYPE
-          Runcible::Models::DebImporter.new(deb_importer_values(capsule))
-        else
-          fail _("Unexpected repo type %s") % self.content_type
-        end
-      end
-
-      def docker_feed_url(capsule = SmartProxy.default_capsule!)
-        pulp_uri = URI.parse(SETTINGS[:katello][:pulp][:url])
-        if capsule.default_capsule?
-          self.url if self.respond_to?(:url)
-        else
-          "https://#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}"
-        end
-      end
-
-      def importer_feed_url(capsule = SmartProxy.default_capsule!)
-        if capsule.default_capsule?
-          self.url if self.respond_to?(:url)
-        else
-          self.full_path(nil, true)
-        end
-      end
-
-      def yum_importer_values(capsule)
-        if capsule.default_capsule?
-          new_download_policy = self.download_policy
-        else
-          new_download_policy = capsule_download_policy(capsule)
-        end
-
-        config = {
-          :feed => self.importer_feed_url(capsule),
-          :download_policy => new_download_policy,
-          :remove_missing => capsule.default_capsule? ? self.mirror_on_sync? : true
-        }
-        config[:type_skip_list] = ignorable_content if ignorable_content
-        config.merge(importer_connection_options(capsule))
-      end
-
-      def proxy_host_value
-        self.ignore_global_proxy ? "" : nil
-      end
-
-      def puppet_importer_values(capsule)
-        config = {
-          :feed => self.importer_feed_url(capsule),
-          :remove_missing => capsule.default_capsule? ? self.mirror_on_sync? : true
-        }
-        config.merge(importer_connection_options(capsule))
-      end
-
-      def deb_importer_values(capsule)
-        config = {
-          feed: self.importer_feed_url(capsule),
-          releases: self.deb_releases,
-          components: self.deb_components,
-          architectures: self.deb_architectures
-        }
-        config.merge(importer_connection_options(capsule))
-      end
-
-      def importer_connection_options(capsule = SmartProxy.default_capsule!)
-        if !capsule.default_capsule?
-          ueber_cert = ::Cert::Certs.ueber_cert(organization)
-          importer_options = {
-            :ssl_client_cert => ueber_cert[:cert],
-            :ssl_client_key => ueber_cert[:key],
-            :ssl_ca_cert => ::Cert::Certs.ca_cert
-          }
-        elsif self.try(:redhat?) && self.content_view.default? && Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
-          importer_options = {
-            :ssl_client_cert => self.product.certificate,
-            :ssl_client_key => self.product.key,
-            :ssl_ca_cert => Katello::Repository.feed_ca_cert(url),
-            :proxy_host => self.proxy_host_value
-          }
-        elsif self.ssl_client_cert && self.ssl_client_key && self.ssl_ca_cert
-          importer_options = {
-            :ssl_client_cert => self.ssl_client_cert.content,
-            :ssl_client_key => self.ssl_client_key.content,
-            :ssl_ca_cert => self.ssl_ca_cert.content
-          }
-        else
-          importer_options = {
-            :ssl_client_cert => nil,
-            :ssl_client_key => nil,
-            :ssl_ca_cert => nil,
-            :proxy_host => self.proxy_host_value
-          }
-        end
-        unless self.is_a?(::Katello::ContentViewPuppetEnvironment)
-          importer_options.merge!(:ssl_validation => verify_ssl_on_sync?)
-          if capsule.default_capsule?
-            importer_options.merge!(:basic_auth_username => upstream_username,
-                                    :basic_auth_password => upstream_password)
-          end
-        end
-        importer_options
+        backend_service(capsule).generate_importer
       end
 
       def generate_distributors(capsule = SmartProxy.default_capsule!)
-        case self.content_type
-        when Repository::YUM_TYPE
-          yum_dist_id = self.pulp_id
-          yum_dist_options = {:protected => true, :id => yum_dist_id, :auto_publish => true}
-          yum_dist_options[:skip] = ignorable_content if ignorable_content
-          #check the instance variable, as we do not want to go to pulp
-          yum_dist_options['checksum_type'] = self.saved_checksum_type || self.checksum_type
-          yum_dist = Runcible::Models::YumDistributor.new(self.relative_path, self.unprotected, true,
-                                                          yum_dist_options)
-          clone_dist = Runcible::Models::YumCloneDistributor.new(:id => "#{self.pulp_id}_clone",
-                                                                 :destination_distributor_id => yum_dist_id)
-          export_dist = Runcible::Models::ExportDistributor.new(false, false, self.relative_path)
-          distributors = [yum_dist, export_dist]
-          distributors << clone_dist if capsule.default_capsule?
-        when Repository::FILE_TYPE
-          dist = Runcible::Models::IsoDistributor.new(self.relative_path, self.unprotected, true, auto_publish: true)
-          distributors = [dist]
-        when Repository::PUPPET_TYPE
-          capsule ||= SmartProxy.default_capsule!
-          dist_options = { :id => self.pulp_id, :auto_publish => true }
-          repo_path =  File.join(capsule.puppet_path,
-                                 Environment.construct_name(self.organization,
-                                                            self.environment,
-                                                            self.content_view),
-                                 'modules')
-          puppet_install_dist = Runcible::Models::PuppetInstallDistributor.new(repo_path, dist_options)
-
-          dist_options[:id] = "#{self.pulp_id}_puppet"
-          puppet_dist = Runcible::Models::PuppetDistributor.new(nil, (self.unprotected || false),
-                                                                true, dist_options)
-
-          distributors = [puppet_dist, puppet_install_dist]
-        when Repository::DOCKER_TYPE
-          options = { :protected => !self.unprotected, :id => self.pulp_id, :auto_publish => true,
-                      :repo_registry_id => container_repository_name}
-          docker_dist = Runcible::Models::DockerDistributor.new(options)
-          distributors = [docker_dist]
-        when Repository::OSTREE_TYPE
-          options = { :id => self.pulp_id,
-                      :auto_publish => true,
-                      :relative_path => relative_path,
-                      :depth => self.root.compute_ostree_upstream_sync_depth }
-
-          dist = Runcible::Models::OstreeDistributor.new(options)
-          distributors = [dist]
-        when Repository::DEB_TYPE
-          options = {
-            id: self.pulp_id,
-            auto_publish: true
-          }
-          http = self.unprotected
-          https = true
-          dist = Runcible::Models::DebDistributor.new(self.relative_path, http, https, options)
-          distributors = [dist]
-        else
-          fail _("Unexpected repo type %s") % self.content_type
-        end
-
-        distributors
-      end
-
-      def importer_type
-        case self.content_type
-        when Repository::YUM_TYPE
-          Runcible::Models::YumImporter::ID
-        when Repository::FILE_TYPE
-          Runcible::Models::IsoImporter::ID
-        when Repository::PUPPET_TYPE
-          Runcible::Models::PuppetImporter::ID
-        when Repository::DOCKER_TYPE
-          Runcible::Models::DockerImporter::ID
-        when Repository::OSTREE_TYPE
-          Runcible::Models::OstreeImporter::ID
-        when Repository::DEB_TYPE
-          Runcible::Models::DebImporter::ID
-        else
-          fail _("Unexpected repo type %s") % self.content_type
-        end
+        backend_service(capsule).generate_distributors
       end
 
       def populate_from(repos_map)
@@ -575,14 +353,13 @@ module Katello
           generated.delete('checksum_type')
           actual.delete('checksum_type')
         end
-        generated.delete('repo-registry-id')
-        generated == actual
+        generated.compact == actual.compact
       end
 
       def importer_matches?(capsule_importer, capsule)
         generated_importer = self.generate_importer(capsule)
         capsule_importer.try(:[], 'importer_type_id') == generated_importer.id &&
-          generated_importer.config == capsule_importer['config']
+            generated_importer.config.compact == capsule_importer['config'].compact
       end
 
       protected
@@ -635,9 +412,9 @@ module Katello
       if self.master?
         Katello::Rpm.import_for_repository(self, full_index)
         Katello::Srpm.import_for_repository(self, full_index)
+        Katello::ModuleStream.import_for_repository(self)
         Katello::Erratum.import_for_repository(self)
         Katello::PackageGroup.import_for_repository(self)
-        Katello::ModuleStream.import_for_repository(self)
         self.import_distribution_data
       else
         index_linked_repo

data/app/models/katello/gpg_key.rb

@@ -2,6 +2,7 @@ module Katello
   class GpgKey < Katello::Model
     audited :associations => [:products]
 
+    include ForemanTasks::Concerns::ActionSubject
     include Katello::Authorization::GpgKey
     MAX_CONTENT_LINE_LENGTH = 65
 

data/app/models/katello/host/content_facet.rb

@@ -19,6 +19,9 @@ module Katello
       has_many :content_facet_applicable_rpms, :class_name => "Katello::ContentFacetApplicableRpm", :dependent => :delete_all, :inverse_of => :content_facet
       has_many :applicable_rpms, :through => :content_facet_applicable_rpms, :class_name => "Katello::Rpm", :source => :rpm
 
+      has_many :content_facet_applicable_module_streams, :class_name => "Katello::ContentFacetApplicableModuleStream", :dependent => :delete_all, :inverse_of => :content_facet
+      has_many :applicable_module_streams, :through => :content_facet_applicable_module_streams, :class_name => "Katello::ModuleStream", :source => :module_stream
+
       validates :content_view, :presence => true, :allow_blank => false
       validates :lifecycle_environment, :presence => true, :allow_blank => false
       validates_with ::AssociationExistsValidator, attributes: [:content_source]
@@ -49,21 +52,15 @@ module Katello
       end
 
       def installable_errata(env = nil, content_view = nil)
-        repos = if env && content_view
-                  Katello::Repository.in_environment(env).in_content_views([content_view])
-                else
-                  self.bound_repositories.pluck(:id)
-                end
-        self.applicable_errata.in_repositories(repos)
+        ApplicableContentHelper.new(Erratum, self).installable(env, content_view)
       end
 
       def installable_rpms(env = nil, content_view = nil)
-        repos = if env && content_view
-                  Katello::Repository.in_environment(env).in_content_views([content_view])
-                else
-                  self.bound_repositories.pluck(:id)
-                end
-        self.applicable_rpms.in_repositories(repos)
+        ApplicableContentHelper.new(Rpm, self).installable(env, content_view)
+      end
+
+      def installable_module_streams(env = nil, content_view = nil)
+        ApplicableContentHelper.new(ModuleStream, self).installable(env, content_view)
       end
 
       def errata_counts
@@ -77,6 +74,7 @@ module Katello
       end
 
       def import_applicability(partial = false)
+        import_module_stream_applicability(partial)
         import_errata_applicability(partial)
         import_rpm_applicability(partial)
         update_applicability_counts
@@ -88,54 +86,24 @@ module Katello
             :installable_bugfix_errata_count => self.installable_errata.bugfix.count,
             :installable_enhancement_errata_count => self.installable_errata.enhancement.count,
             :applicable_rpm_count => self.content_facet_applicable_rpms.count,
-            :upgradable_rpm_count => self.installable_rpms.count
+            :upgradable_rpm_count => self.installable_rpms.count,
+            :applicable_module_stream_count => self.content_facet_applicable_module_streams.count,
+            :upgradable_module_stream_count => self.installable_module_streams.count
         )
         self.save!(:validate => false)
       end
 
       def import_rpm_applicability(partial)
-        to_add, to_remove = applicable_rpm_differences(partial)
-        Katello::ContentFacetApplicableRpm.where(:content_facet_id => self.id).delete_all unless partial
-        ActiveRecord::Base.transaction do
-          insert_rpm_applicability(to_add) unless to_add.blank?
-          remove_rpm_applicability(to_remove) unless to_remove.blank?
-        end
+        ApplicableContentHelper.new(Rpm, self).import(partial)
       end
 
       def import_errata_applicability(partial)
-        to_add, to_remove = applicable_errata_differences(partial)
-        Katello::ContentFacetErratum.where(:content_facet_id => self.id).delete_all unless partial
-        ActiveRecord::Base.transaction do
-          insert_errata_applicability(to_add) unless to_add.blank?
-          remove_errata_applicability(to_remove) unless to_remove.blank?
-        end
+        ApplicableContentHelper.new(Erratum, self).import(partial)
         self.update_errata_status
       end
 
-      def applicable_errata_differences(partial)
-        errata_uuids = ::Katello::Pulp::Consumer.new(self.uuid).applicable_errata_ids
-        if partial
-          consumer_uuids = applicable_errata.pluck("#{Erratum.table_name}.uuid")
-          to_remove = consumer_uuids - errata_uuids
-          to_add = errata_uuids - consumer_uuids
-        else
-          to_add = errata_uuids
-          to_remove = nil
-        end
-        [to_add, to_remove]
-      end
-
-      def applicable_rpm_differences(partial)
-        rpm_uuids = ::Katello::Pulp::Consumer.new(self.uuid).applicable_rpm_ids
-        if partial
-          consumer_uuids = applicable_rpms.pluck("#{Rpm.table_name}.uuid")
-          to_remove = consumer_uuids - rpm_uuids
-          to_add = rpm_uuids - consumer_uuids
-        else
-          to_add = rpm_uuids
-          to_remove = nil
-        end
-        [to_add, to_remove]
+      def import_module_stream_applicability(partial)
+        ApplicableContentHelper.new(ModuleStream, self).import(partial)
       end
 
       def self.in_content_view_version_environments(version_environments)
@@ -148,10 +116,27 @@ module Katello
         where(queries.join(" OR "))
       end
 
-      def self.with_non_installable_errata(errata)
-        subquery = Katello::Erratum.select("#{Katello::Erratum.table_name}.id").ids_installable_for_hosts
-        .where("#{Katello::ContentFacetRepository.table_name}.content_facet_id = #{Katello::Host::ContentFacet.table_name}.id").to_sql
-        self.joins(:applicable_errata).where("#{Katello::Erratum.table_name}.id" => errata).where("#{Katello::Erratum.table_name}.id NOT IN (#{subquery})").distinct
+      def self.with_non_installable_errata(errata, hosts = nil)
+        content_facets = Katello::Host::ContentFacet.select(:id).where(:host_id => hosts)
+        reachable_repos = ::Katello::ContentFacetRepository.where(content_facet_id: content_facets).distinct.pluck(:repository_id)
+        installable_errata = ::Katello::ContentFacetErratum.select(:id).
+          where(content_facet_id: content_facets).
+          joins(
+          "inner join #{::Katello::RepositoryErratum.table_name} ON #{Katello::ContentFacetErratum.table_name}.erratum_id = #{Katello::RepositoryErratum.table_name}.erratum_id",
+          "inner JOIN #{Katello::ContentFacetRepository.table_name} "\
+            "ON #{Katello::ContentFacetErratum.table_name}.content_facet_id = #{Katello::ContentFacetRepository.table_name}.content_facet_id "\
+            "AND #{Katello::RepositoryErratum.table_name}.repository_id = #{Katello::ContentFacetRepository.table_name}.repository_id"
+          ).
+          where("#{Katello::RepositoryErratum.table_name}.repository_id" => reachable_repos).
+          where("#{Katello::RepositoryErratum.table_name}.erratum_id" => errata).
+          where("#{Katello::ContentFacetRepository.table_name}.repository_id" => reachable_repos).
+          where("#{Katello::ContentFacetRepository.table_name}.content_facet_id" => content_facets)
+
+        non_installable_errata = ::Katello::ContentFacetErratum.select(:content_facet_id).
+          where.not(id: installable_errata).
+          where(content_facet_id: content_facets, erratum_id: errata)
+
+        Katello::Host::ContentFacet.where(id: non_installable_errata)
       end
 
       def self.with_applicable_errata(errata)
@@ -207,36 +192,6 @@ module Katello
         facet_attributes[:content_source_id] ||= hostgroup.inherited_content_source_id
         facet_attributes
       end
-
-      private
-
-      def insert_rpm_applicability(uuids)
-        applicable_rpm_ids = ::Katello::Rpm.where(:uuid => uuids).pluck(:id)
-        unless applicable_rpm_ids.empty?
-          inserts = applicable_rpm_ids.map { |erratum_id| "(#{erratum_id.to_i}, #{self.id.to_i})" }
-          sql = "INSERT INTO #{Katello::ContentFacetApplicableRpm.table_name} (rpm_id, content_facet_id) VALUES #{inserts.join(', ')}"
-          ActiveRecord::Base.connection.execute(sql)
-        end
-      end
-
-      def remove_rpm_applicability(uuids)
-        applicable_rpm_ids = ::Katello::Rpm.where(:uuid => uuids).pluck(:id)
-        Katello::ContentFacetApplicableRpm.where(:content_facet_id => self.id, :rpm_id => applicable_rpm_ids).delete_all
-      end
-
-      def insert_errata_applicability(uuids)
-        applicable_errata_ids = ::Katello::Erratum.where(:uuid => uuids).pluck(:id)
-        unless applicable_errata_ids.empty?
-          inserts = applicable_errata_ids.map { |erratum_id| "(#{erratum_id.to_i}, #{self.id.to_i})" }
-          sql = "INSERT INTO #{Katello::ContentFacetErratum.table_name} (erratum_id, content_facet_id) VALUES #{inserts.join(', ')}"
-          ActiveRecord::Base.connection.execute(sql)
-        end
-      end
-
-      def remove_errata_applicability(uuids)
-        applicable_errata_ids = ::Katello::Erratum.where(:uuid => uuids).pluck(:id)
-        Katello::ContentFacetErratum.where(:content_facet_id => self.id, :erratum_id => applicable_errata_ids).delete_all
-      end
     end
   end
 end