katello 4.5.0.rc2 → 4.6.0.rc2

data/app/models/katello/alternate_content_source.rb

@@ -1,5 +1,7 @@
 module Katello
   class AlternateContentSource < Katello::Model
+    audited
+
     include Ext::LabelFromName
     include Encryptable
     include ::ScopedSearchExtensions
@@ -8,9 +10,9 @@ module Katello
 
     self.table_name = :katello_alternate_content_sources
 
-    # TODO: simplified, rhui
-    ACS_TYPES = %w(custom).freeze
+    ACS_TYPES = %w(custom simplified).freeze
     CONTENT_TYPES = [::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE].freeze
+    AUDIT_REFRESH_ACTION = 'refresh'.freeze
 
     encrypts :upstream_password
 
@@ -18,18 +20,27 @@ module Katello
     belongs_to :ssl_client_cert, inverse_of: :ssl_client_alternate_content_sources, class_name: "Katello::ContentCredential"
     belongs_to :ssl_client_key, inverse_of: :ssl_key_alternate_content_sources, class_name: "Katello::ContentCredential"
     belongs_to :http_proxy, inverse_of: :alternate_content_sources
-    has_many :smart_proxy_alternate_content_sources, dependent: :destroy,
+
+    has_many :alternate_content_source_products, dependent: :delete_all, inverse_of: :alternate_content_source,
+             class_name: "Katello::AlternateContentSourceProduct"
+    has_many :products, through: :alternate_content_source_products, inverse_of: :alternate_content_sources,
+             class_name: "Katello::Product"
+
+    has_many :smart_proxy_alternate_content_sources, dependent: :delete_all,
              inverse_of: :alternate_content_source
-    has_many :smart_proxies, through: :smart_proxy_alternate_content_sources
+    has_many :smart_proxies, -> { distinct }, through: :smart_proxy_alternate_content_sources
 
+    validates :base_url, :subpaths, :verify_ssl, :upstream_username,
+              :upstream_password, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key, if: :simplified?, absence: true
     validates :base_url, if: :custom?, presence: true
+    validates :products, if: :custom?, absence: true
     validates :verify_ssl, if: :custom?, exclusion: [nil]
     validates :alternate_content_source_type, inclusion: {
       in: ->(_) { ACS_TYPES },
       allow_blank: false,
       message: ->(_, _) { _("is not a valid type. Must be one of the following: %s") % ACS_TYPES.join(',') }
     }
-    validates :content_type, if: :custom?, inclusion: {
+    validates :content_type, inclusion: {
       in: ->(_) { RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES },
       allow_blank: false,
       message: ->(_, _) { _("is not allowed for ACS. Must be one of the following: %s") % (RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES).join(',') }
@@ -44,16 +55,28 @@ module Katello
     scoped_search on: :content_type, complete_value: true
     scoped_search on: :alternate_content_source_type, complete_value: true
     scoped_search on: :upstream_username, complete_value: true
-    scoped_search on: :smart_proxy_id, relation: :smart_proxy_alternate_content_sources, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :id, relation: :smart_proxies, rename: :smart_proxy_id, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :name, relation: :smart_proxies, rename: :smart_proxy_name, complete_value: true
+    scoped_search on: :id, relation: :products, rename: :product_id, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :name, relation: :products, rename: :product_name, complete_value: true
 
-    def backend_service(smart_proxy)
-      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy)
+    def backend_service(smart_proxy, repository = nil)
+      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy, repository)
     end
 
     def custom?
       alternate_content_source_type == 'custom'
     end
 
+    def simplified?
+      alternate_content_source_type == 'simplified'
+    end
+
+    def self.with_products(products)
+      products = [products] unless products.is_a?(Array)
+      joins(:alternate_content_source_products).where('katello_alternate_content_source_products.product_id in (:product_ids)', product_ids: products.pluck(:id))
+    end
+
     def self.with_type(content_type)
       where(content_type: content_type)
     end
@@ -67,5 +90,13 @@ module Katello
       @latest_dynflow_refresh_task ||= ForemanTasks::Task::DynflowTask.where(:label => Actions::Katello::AlternateContentSource::Refresh.name).
           for_resource(self).order(:started_at).last
     end
+
+    def audit_refresh
+      write_audit(action: AUDIT_REFRESH_ACTION, comment: _('Successfully refreshed.'), audited_changes: {})
+    end
+
+    def audit_updated_products(old_product_ids)
+      write_audit(action: 'update', comment: _('Products updated.'), audited_changes: { 'product_ids' => [old_product_ids, product_ids] })
+    end
   end
 end

data/app/models/katello/alternate_content_source_product.rb

@@ -0,0 +1,13 @@
+module Katello
+  class AlternateContentSourceProduct < Katello::Model
+    audited
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    self.table_name = :katello_alternate_content_source_products
+    belongs_to :alternate_content_source, inverse_of: :alternate_content_source_products, class_name: 'Katello::AlternateContentSource'
+    belongs_to :product, inverse_of: :alternate_content_source_products, class_name: 'Katello::Product'
+    delegate :custom?, to: :alternate_content_source
+    delegate :simplified?, to: :alternate_content_source
+
+    validates_with Validators::AlternateContentSourceProductsValidator, :attributes => [:product_id], if: :simplified?
+  end
+end

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

@@ -5,11 +5,13 @@ module Katello
     delegate :editable?, to: :product
 
     def deletable?(remove_from_content_view_versions = true)
-      product.editable? && (remove_from_content_view_versions || !promoted? || !self.content_views.generated_for_none.exists?)
+      return false unless product.editable?
+      remove_from_content_view_versions || !promoted? || (self.content_views.exists? && !self.content_views.generated_for_none.exists?)
     end
 
     def redhat_deletable?(remove_from_content_view_versions = false)
-      (remove_from_content_view_versions || !self.promoted? || !self.content_views.generated_for_none.exists?) && self.product.editable?
+      return false unless product.editable?
+      remove_from_content_view_versions || !self.promoted? || (self.content_views.exists? && !self.content_views.generated_for_none.exists?)
     end
 
     def readable?

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

@@ -204,7 +204,16 @@ module Katello
 
       def import_package_profile_in_bulk(simple_packages)
         nvreas = simple_packages.map { |sp| sp.nvrea }
-        found = InstalledPackage.where(:nvrea => nvreas).select(:id, :nvrea).to_a
+        found_nvrea = InstalledPackage.where(:nvrea => nvreas)
+        nil_vendor_installed_packages = found_nvrea.where(vendor: nil)
+        unless nil_vendor_installed_packages.blank?
+          packages_to_update = simple_packages.select { |sp| !sp.vendor.blank? && nil_vendor_installed_packages&.map(&:nvrea)&.include?(sp.nvrea) }
+          packages_to_update.each do |simple_package|
+            nil_vendor_installed_packages.where(nvrea: simple_package.nvrea).update(vendor: simple_package.vendor)
+          end
+        end
+
+        found = found_nvrea.select(:id, :nvrea).to_a
         found_nvreas = found.map(&:nvrea)
 
         new_packages = simple_packages.select { |sp| !found_nvreas.include?(sp.nvrea) }
@@ -217,7 +226,8 @@ module Katello
                                           :epoch => simple_package.epoch,
                                           :version => simple_package.version,
                                           :release => simple_package.release,
-                                          :arch => simple_package.arch)
+                                          :arch => simple_package.arch,
+                                          :vendor => simple_package.vendor)
         end
         InstalledPackage.import(installed_packages, validate: false, on_duplicate_key_ignore: true)
         #re-lookup all imported to pickup any duplicates/conflicts

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

@@ -156,8 +156,8 @@ module Katello
         end
 
         self.joins(repository_association_units).
-            where(repository_association_class.table_name => {:repository_id => facet_repos,
-                                                              content_unit_association_id => facet_content_units}).distinct
+          where(repository_association_class.table_name => { :repository_id => facet_repos,
+                                                             content_unit_association_id => facet_content_units }).distinct
       end
 
       def with_identifiers(ids)

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

@@ -57,6 +57,7 @@ module Katello
         has_many :hostgroup_content_facets, :class_name => "::Katello::Hostgroup::ContentFacet", :foreign_key => :content_source_id,
                               :inverse_of => :content_source, :dependent => :nullify
         has_many :hostgroups, :class_name => "::Hostgroup", :through => :hostgroup_content_facets
+        has_many :smart_proxy_alternate_content_sources, :class_name => "::Katello::SmartProxyAlternateContentSource", :inverse_of => :smart_proxy, :dependent => :delete_all
 
         validates :download_policy, inclusion: {
           :in => DOWNLOAD_POLICIES,
@@ -188,14 +189,12 @@ module Katello
       end
 
       def pulp3_ssl_configuration(config, connection_adapter = Faraday.default_adapter)
-        legacy_pulp_cert = !self.setting(PULP3_FEATURE, 'client_authentication')&.include?('client_certificate')
-
         if connection_adapter == :excon
-          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename(use_admin_as_cn_cert: legacy_pulp_cert)
-          config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename(use_admin_as_cn_cert: legacy_pulp_cert)
+          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename
+          config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename
         elsif connection_adapter == :net_http
-          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert(use_admin_as_cn_cert: legacy_pulp_cert)
-          config.ssl_client_key = ::Cert::Certs.ssl_client_key(use_admin_as_cn_cert: legacy_pulp_cert)
+          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert
+          config.ssl_client_key = ::Cert::Certs.ssl_client_key
         else
           fail "Unexpected connection_adapter #{Faraday.default_adapter}!  Cannot continue, this is likely a bug."
         end

data/app/models/katello/content_view.rb

@@ -33,49 +33,50 @@ module Katello
     has_many :content_view_repositories, :class_name => 'Katello::ContentViewRepository',
              :dependent => :destroy, :inverse_of => :content_view
     has_many :repositories, :through => :content_view_repositories, :class_name => "Katello::Repository",
-                            :after_remove => :remove_repository
+             :after_remove => :remove_repository
 
     has_many :filters, :dependent => :destroy, :class_name => "Katello::ContentViewFilter"
 
     has_many :activation_keys, :class_name => "Katello::ActivationKey", :dependent => :restrict_with_exception
 
     has_many :content_facets, :class_name => "Katello::Host::ContentFacet",
-                          :inverse_of => :content_view, :dependent => :restrict_with_exception
-    has_many :hosts,      :class_name => "::Host::Managed", :through => :content_facets,
-                          :inverse_of => :content_view
+             :inverse_of => :content_view, :dependent => :restrict_with_exception
+    has_many :hosts, :class_name => "::Host::Managed", :through => :content_facets,
+             :inverse_of => :content_view
     has_many :hostgroup_content_facets, :class_name => "Katello::Hostgroup::ContentFacet",
-                          :inverse_of => :content_view, :dependent => :nullify
+             :inverse_of => :content_view, :dependent => :nullify
     has_many :hostgroups, :class_name => "::Hostgroup", :through => :hostgroup_content_facets,
-                          :inverse_of => :content_view
+             :inverse_of => :content_view
 
     has_many :repository_references, :class_name => 'Katello::Pulp3::RepositoryReference',
              :dependent => :destroy, :inverse_of => :content_view
 
     validates_lengths_from_database :except => [:label]
-    validates :label, :uniqueness => {:scope => :organization_id},
-                      :presence => true
-    validates :name, :presence => true, :uniqueness => {:scope => :organization_id}
+    validates :label, :uniqueness => { :scope => :organization_id },
+              :presence => true
+    validates :name, :presence => true, :uniqueness => { :scope => :organization_id }
     validates :organization_id, :presence => true
     validate :check_non_composite_components
     validate :check_docker_conflicts
     validate :check_non_composite_auto_publish
+    validate :check_default_label_name, if: :default?
     validates :composite, :inclusion => [true, false]
     validates :composite,
-              inclusion: { in: [false], message: "Composite Content Views can not solve dependencies"},
+              inclusion: { in: [false], message: "Composite Content Views can not solve dependencies" },
               if: :solve_dependencies
     validates :import_only, :inclusion => [true, false]
     validates :import_only,
-              inclusion: { in: [false], message: "Import-only Content Views can not be Composite"},
+              inclusion: { in: [false], message: "Import-only Content Views can not be Composite" },
               if: :composite
     validates :import_only,
-              inclusion: { in: [false], message: "Import-only Content Views can not solve dependencies"},
+              inclusion: { in: [false], message: "Import-only Content Views can not solve dependencies" },
               if: :solve_dependencies
     validate :import_only_immutable
     validates :generated_for,
-              exclusion: { in: [:none], message: "Generated Content Views can not be Composite"},
+              exclusion: { in: [:none], message: "Generated Content Views can not be Composite" },
               if: :composite
     validates :generated_for,
-              exclusion: { in: [:none], message: "Generated Content Views can not solve dependencies"},
+              exclusion: { in: [:none], message: "Generated Content Views can not solve dependencies" },
               if: :solve_dependencies
 
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
@@ -87,8 +88,12 @@ module Katello
     scope :non_composite, -> { where(:composite => [nil, false]) }
     scope :generated, -> { where.not(:generated_for => :none) }
     scope :generated_for_repository, -> { where(:generated_for => [:repository_export, :repository_import]) }
-    scope :not_generated_for_repository, -> { where.not(id: generated_for_repository) }
-
+    scope :ignore_generated, -> {
+      where.not(:generated_for => [:repository_export,
+                                   :repository_import,
+                                   :library_export_syncable,
+                                   :repository_export_syncable])
+    }
     scope :generated_for_library, -> { where(:generated_for => [:library_export, :library_import]) }
 
     scoped_search :on => :name, :complete_value => true
@@ -103,7 +108,9 @@ module Katello
       library_export: 1,
       repository_export: 2,
       library_import: 3,
-      repository_import: 4
+      repository_import: 4,
+      library_export_syncable: 5,
+      repository_export_syncable: 6
     }, _prefix: true
 
     set_crud_hooks :content_view
@@ -203,6 +210,10 @@ module Katello
         new_view.filters << new_filter
 
         case filter.type
+        when ContentViewDebFilter.name
+          filter.deb_rules.each do |rule|
+            new_filter.deb_rules << rule.dup
+          end
         when ContentViewPackageFilter.name
           filter.package_rules.each do |rule|
             new_filter.package_rules << rule.dup
@@ -279,6 +290,7 @@ module Katello
       required :env, 'Katello::KTEnvironment', desc: 'a __Katello::KTEnvironment__ object for which we load the __Katello::ContentViewVersion__ object'
       returns 'Katello::ContentViewVersion'
     end
+
     def version(env)
       self.versions.in_environment(env).order("#{Katello::ContentViewVersion.table_name}.id ASC").readonly(false).last
     end
@@ -306,7 +318,7 @@ module Katello
 
     def history
       Katello::ContentViewHistory.joins(:content_view_version).where(
-          "#{Katello::ContentViewVersion.table_name}.content_view_id" => self.id)
+        "#{Katello::ContentViewVersion.table_name}.content_view_id" => self.id)
     end
 
     def version_environment(env)
@@ -387,7 +399,7 @@ module Katello
     end
 
     def auto_publish_components
-      component_composites.where(latest: true).joins(:composite_content_view).where(self.class.table_name => {auto_publish: true})
+      component_composites.where(latest: true).joins(:composite_content_view).where(self.class.table_name => { auto_publish: true })
     end
 
     def publish_repositories(override_components = nil)
@@ -446,8 +458,8 @@ module Katello
     def get_repo_clone(env, repo)
       lib_id = repo.library_instance_id || repo.id
       Repository.in_environment(env).where(:library_instance_id => lib_id).
-          joins(:content_view_version).
-          where("#{Katello::ContentViewVersion.table_name}.content_view_id" => self.id)
+        joins(:content_view_version).
+        where("#{Katello::ContentViewVersion.table_name}.content_view_id" => self.id)
     end
 
     def delete(from_env)
@@ -497,9 +509,15 @@ module Katello
       end
     end
 
+    def check_default_label_name
+      if default? && !(name == 'Default Organization View' && label == 'Default_Organization_View')
+        errors.add(:base, _("Name and label of default content view should not be changed"))
+      end
+    end
+
     def check_docker_conflicts
       duplicate_docker_repos.each do |repo|
-        msg = _("Container Image repo '%{repo}' is present in multiple component content views.") % {repo: repo.name}
+        msg = _("Container Image repo '%{repo}' is present in multiple component content views.") % { repo: repo.name }
         errors.add(:base, msg)
       end
     end
@@ -526,7 +544,7 @@ module Katello
                                        :environment_id => env.id,
                                        :content_view => self,
                                        :content_view_version => version
-                                      )
+        )
       end
     end
 
@@ -555,7 +573,7 @@ module Katello
                                            :minor => minor,
                                            :content_view => self,
                                            :components => components
-                                          )
+      )
 
       update(:next_version => major.to_i + 1) unless major.to_i < next_version
       version
@@ -626,14 +644,14 @@ module Katello
     def check_remove_from_environment!(env)
       errors = []
 
-      dependencies = {hosts: _("hosts"),
-                      activation_keys: _("activation keys")
+      dependencies = { hosts: _("hosts"),
+                       activation_keys: _("activation keys")
       }
 
       dependencies.each do |key, name|
         if (models = self.association(key).scope.in_environment(env)).any?
           errors << _("Cannot remove '%{view}' from environment '%{env}' due to associated %{dependent}: %{names}.") %
-            {view: self.name, env: env.name, dependent: name, names: models.map(&:name).join(", ")}
+            { view: self.name, env: env.name, dependent: name, names: models.map(&:name).join(", ") }
         end
       end
 
@@ -644,15 +662,15 @@ module Katello
     def check_ready_to_destroy!
       errors = []
 
-      dependencies = {environments: _("environments"),
-                      hosts: _("hosts"),
-                      activation_keys: _("activation keys")
+      dependencies = { environments: _("environments"),
+                       hosts: _("hosts"),
+                       activation_keys: _("activation keys")
       }
 
       dependencies.each do |key, name|
         if (models = self.association(key).scope).any?
           errors << _("Cannot delete '%{view}' due to associated %{dependent}: %{names}.") %
-            {view: self.name, dependent: name, names: models.map(&:name).join(", ")}
+            { view: self.name, dependent: name, names: models.map(&:name).join(", ") }
         end
       end
 
@@ -700,7 +718,7 @@ module Katello
     def remove_repository(repository)
       filters.each do |filter_item|
         repo_exists = Repository.unscoped.joins(:filters).where(
-            ContentViewFilter.table_name => {:id => filter_item.id}, :id => repository.id).count
+          ContentViewFilter.table_name => { :id => filter_item.id }, :id => repository.id).count
         if repo_exists
           filter_item.repositories.delete(repository)
           filter_item.save!

data/app/models/katello/content_view_deb_filter.rb

@@ -0,0 +1,51 @@
+module Katello
+  class ContentViewDebFilter < ContentViewFilter
+    CONTENT_TYPE = Deb::CONTENT_TYPE
+
+    has_many :deb_rules, :dependent => :destroy, :foreign_key => :content_view_filter_id,
+                                   :class_name => "Katello::ContentViewDebFilterRule"
+    validates_lengths_from_database
+
+    def generate_clauses(repo)
+      package_filenames = []
+
+      self.deb_rules.each do |rule|
+        package_filenames.concat(query_debs(repo, rule))
+      end
+
+      ContentViewDebFilter.generate_deb_clauses(package_filenames)
+    end
+
+    def content_unit_pulp_ids(repo)
+      deb_filenames = []
+      self.deb_rules.each do |rule|
+        deb_filenames.concat(query_debs(repo, rule))
+      end
+      debs = Deb.in_repositories(repo)
+      debs.where(filename: deb_filenames).pluck(:pulp_id).flatten.uniq
+    end
+
+    def self.generate_deb_clauses(package_filenames = [])
+      { 'filename' => { "$in" => package_filenames } } unless package_filenames.empty?
+    end
+
+    def applicable_debs
+      Deb.in_repositories(self.applicable_repos)
+    end
+
+    def query_debs(repo, rule)
+      debs = Deb.in_repositories(repo)
+      query_debs_from_collection(debs, rule).pluck("#{Deb.table_name}.filename")
+    end
+
+    def query_debs_from_collection(collection, rule)
+      query_name = rule.name.tr("*", "%")
+      query = collection.where("#{Deb.table_name}.name ilike ?", query_name)
+      if rule.architecture.present?
+        query_arch = rule.architecture.tr("*", "%")
+        query = query.where("#{Deb.table_name}.architecture ilike ?", query_arch)
+      end
+      query.default_sort
+    end
+  end
+end

data/app/models/katello/content_view_deb_filter_rule.rb

@@ -0,0 +1,24 @@
+module Katello
+  class ContentViewDebFilterRule < Katello::Model
+    include ::Katello::Concerns::ContentViewFilterRuleCommon
+
+    belongs_to :filter,
+               :class_name => "Katello::ContentViewDebFilter",
+               :inverse_of => :deb_rules,
+               :foreign_key => :content_view_filter_id
+
+    validates :name, :presence => true
+    validate :ensure_unique_attributes
+    validates_with Validators::ContentViewFilterVersionValidator
+
+    def ensure_unique_attributes
+      other = self.class.where(:name => self.name,
+                               :content_view_filter_id => self.content_view_filter_id,
+                               :architecture => self.architecture)
+      other = other.where.not(:id => self.id) if self.id
+      if other.exists?
+        errors.add(:base, "This deb package filter rule already exists.")
+      end
+    end
+  end
+end

data/app/models/katello/content_view_filter.rb

@@ -9,7 +9,7 @@ module Katello
     MODULE_STREAM   = ModuleStream::CONTENT_TYPE
     DEB             = Deb::CONTENT_TYPE
     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
+    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,6 +31,7 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :type, :rename => :content_type,
                   :complete_value => {Rpm::CONTENT_TYPE.to_sym => "Katello::ContentViewPackageFilter",
+                                      Deb::CONTENT_TYPE.to_sym => "Katello::ContentViewDebFilter",
                                       PackageGroup::CONTENT_TYPE.to_sym => "Katello::ContentViewPackageGroupFilter",
                                       Erratum::CONTENT_TYPE.to_sym => "Katello::ContentViewErratumFilter",
                                       DOCKER.to_sym => "Katello::ContentViewDockerFilter",
@@ -47,8 +48,7 @@ module Katello
     end
 
     def self.deb
-      # TODO
-      []
+      where(:type => ::Katello::ContentViewDebFilter.name)
     end
 
     def self.docker
@@ -69,6 +69,7 @@ module Katello
 
     def content_type
       {
+        ContentViewDebFilter => DEB,
         ContentViewPackageFilter => RPM,
         ContentViewErratumFilter => ERRATA,
         ContentViewPackageGroupFilter => PACKAGE_GROUP,
@@ -79,6 +80,8 @@ module Katello
 
     def self.class_for(content_type)
       case content_type
+      when DEB
+        ContentViewDebFilter
       when RPM
         ContentViewPackageFilter
       when PACKAGE_GROUP
@@ -97,6 +100,8 @@ module Katello
 
     def self.rule_class_for(filter)
       case filter.type
+      when ContentViewDebFilter.name
+        ContentViewDebFilterRule
       when ContentViewPackageFilter.name
         ContentViewPackageFilterRule
       when ContentViewPackageGroupFilter.name
@@ -115,6 +120,8 @@ module Katello
 
     def self.rule_ids_for(filter)
       case filter.type
+      when ContentViewDebFilter.name
+        filter.deb_rule_ids
       when ContentViewPackageFilter.name
         filter.package_rule_ids
       when ContentViewPackageGroupFilter.name

data/app/models/katello/glue/candlepin/owner.rb

@@ -30,7 +30,6 @@ module Katello
       def owner_details
         @owner_details ||= find_owner
         @owner_details['virt_who'] ||= self.subscriptions.using_virt_who.any?
-
         @owner_details
       end
 

data/app/models/katello/installed_package.rb

@@ -23,5 +23,6 @@ module Katello
     scoped_search :on => :version
     scoped_search :on => :release
     scoped_search :on => :arch
+    scoped_search :on => :vendor, :complete_value => true
   end
 end

data/app/models/katello/product.rb

@@ -28,6 +28,9 @@ module Katello
     has_many :pools, :through => :pool_products
     has_many :subscriptions, :through => :pools, :dependent => :destroy
 
+    has_many :alternate_content_source_products, dependent: :delete_all, inverse_of: :product, :class_name => "Katello::AlternateContentSourceProduct"
+    has_many :alternate_content_sources, :through => :alternate_content_source_products, :inverse_of => :products, :class_name => "Katello::AlternateContentSource"
+
     validates_lengths_from_database :except => [:label]
     validates :provider_id, :presence => true
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name

data/app/models/katello/repository.rb

@@ -31,7 +31,7 @@ module Katello
     ANSIBLE_COLLECTION_TYPE = 'ansible_collection'.freeze
     GENERIC_TYPE = 'generic'.freeze
 
-    EXPORTABLE_TYPES = [YUM_TYPE, FILE_TYPE, ANSIBLE_COLLECTION_TYPE].freeze
+    EXPORTABLE_TYPES = [YUM_TYPE, FILE_TYPE, ANSIBLE_COLLECTION_TYPE, DOCKER_TYPE].freeze
 
     define_model_callbacks :sync, :only => :after
 
@@ -110,6 +110,8 @@ module Katello
 
     has_many :smart_proxy_sync_histories, :class_name => "::Katello::SmartProxySyncHistory", :inverse_of => :repository, :dependent => :delete_all
 
+    has_many :smart_proxy_alternate_content_sources, :class_name => 'Katello::SmartProxyAlternateContentSource', :inverse_of => :repository, :dependent => :nullify
+
     validates_with Validators::ContainerImageNameValidator, :attributes => :container_repository_name, :allow_blank => false, :if => :docker?
     validates :container_repository_name, :if => :docker?, :uniqueness => {message: ->(object, _data) do
       _("for repository '%{name}' is not unique and cannot be created in '%{env}'. Its Container Repository Name (%{container_name}) conflicts with an existing repository.  Consider changing the Lifecycle Environment's Registry Name Pattern to something more specific.") %
@@ -339,7 +341,7 @@ module Katello
 
     def published_in_versions
       Katello::ContentViewVersion.with_repositories(self.library_instances_inverse)
-                                 .where(content_view_id: Katello::ContentView.not_generated_for_repository).distinct
+                                 .where(content_view_id: Katello::ContentView.ignore_generated).distinct
     end
 
     def self.errata_with_package_counts(repo)
@@ -666,7 +668,7 @@ module Katello
 
     def self.smart_proxy_syncable
       joins(:content_view_version => :content_view).
-        merge(ContentView.not_generated_for_repository).
+        merge(ContentView.ignore_generated).
         where.not(environment_id: nil)
     end
 

data/app/models/katello/rpm.rb

@@ -17,6 +17,7 @@ module Katello
     scoped_search :on => :evr, :ext_method => :scoped_search_evr, :only_explicit => true
     scoped_search :on => :filename, :complete_value => true
     scoped_search :on => :sourcerpm, :complete_value => true
+    scoped_search :on => :nvra, :complete_value => true
     scoped_search :on => :modular, :complete_value => true, :only_explicit => true
     scoped_search :on => :checksum
 

data/app/models/katello/smart_proxy_alternate_content_source.rb

@@ -1,8 +1,14 @@
 module Katello
   class SmartProxyAlternateContentSource < Katello::Model
+    audited
     # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
     self.table_name = :katello_smart_proxy_alternate_content_sources
     belongs_to :smart_proxy, :inverse_of => :smart_proxy_alternate_content_sources, :class_name => 'SmartProxy'
     belongs_to :alternate_content_source, :inverse_of => :smart_proxy_alternate_content_sources, :class_name => 'Katello::AlternateContentSource'
+    belongs_to :repository, :inverse_of => :smart_proxy_alternate_content_sources, :class_name => 'Katello::Repository'
+
+    def backend_service
+      @service ||= ::Katello::Pulp3::AlternateContentSource.new(alternate_content_source, smart_proxy, repository)
+    end
   end
 end