katello 4.18.1 → 4.19.0.rc1

data/app/lib/actions/katello/content_view/add_rolling_repo_clone.rb

@@ -2,36 +2,30 @@ module Actions
   module Katello
     module ContentView
       class AddRollingRepoClone < Actions::EntryAction
-        include Helpers::SmartProxySyncHelper
-
-        def plan(content_view, repository_ids)
-          library = content_view.organization.library
+        def plan(content_view, repository_ids, environment_ids)
           clone_ids = []
+          environments = ::Katello::KTEnvironment.where(id: environment_ids)
+          repositories = ::Katello::Repository.where(id: repository_ids)
 
-          concurrence do
-            ::Katello::Repository.where(id: repository_ids).each do |repository|
-              sequence do
-                clone = content_view.get_repo_clone(library, repository).first
-                if clone.nil?
-                  clone = repository.build_clone(content_view: content_view, environment: library)
-                  clone.save!
-                end
-                plan_action(RefreshRollingRepo, clone, false)
+          environments.each do |environment|
+            concurrence do
+              repositories.each do |repository|
+                sequence do
+                  clone = content_view.get_repo_clone(environment, repository).first
+                  if clone.nil?
+                    clone = repository.build_clone(content_view: content_view, environment: environment)
+                    clone.save!
+                  end
+                  plan_action(RefreshRollingRepo, clone, false)
 
-                view_env_cp_id = content_view.content_view_environment(library).cp_id
-                content_id = repository.content_id
-                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env_cp_id, :content_id => content_id)
-                clone_ids << clone.id
+                  view_env_cp_id = content_view.content_view_environment(environment).cp_id
+                  content_id = repository.content_id
+                  plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env_cp_id, :content_id => content_id)
+                  clone_ids << clone.id
+                end
               end
             end
           end
-          plan_self(repository_ids: clone_ids)
-        end
-
-        def run
-          ::Katello::Repository.where(id: input[:repository_ids]).each do |repository|
-            schedule_async_repository_proxy_sync(repository)
-          end
         end
       end
     end

data/app/lib/actions/katello/content_view/create.rb

@@ -2,20 +2,25 @@ module Actions
   module Katello
     module ContentView
       class Create < Actions::Base
-        def plan(content_view)
+        def plan(content_view, environment_ids = [])
           content_view.save!
           if content_view.rolling?
-            plan_action(AddToEnvironment, content_view.create_new_version, content_view.organization.library)
+            new_version = content_view.create_new_version
+            if environment_ids&.any?
+              ::Katello::KTEnvironment.where(id: environment_ids).each do |environment|
+                plan_action(AddToEnvironment, new_version, environment)
+              end
+            end
             repository_ids = content_view.repository_ids
             if repository_ids.any?
               content_view.reload
-              plan_action(AddRollingRepoClone, content_view, repository_ids)
+              plan_action(AddRollingRepoClone, content_view, repository_ids, environment_ids)
             end
           end
         end
 
         def humanized_name
-          _("Create")
+          _("Create content view")
         end
       end
     end

data/app/lib/actions/katello/content_view/refresh_rolling_repo.rb

@@ -2,6 +2,8 @@ module Actions
   module Katello
     module ContentView
       class RefreshRollingRepo < Actions::EntryAction
+        include Helpers::SmartProxySyncHelper
+
         def plan(repository, contents_changed)
           action_subject repository
           sequence do
@@ -23,8 +25,10 @@ module Actions
           repository.last_contents_changed = DateTime.now if repository.version_href != library_instance.version_href
 
           repository.version_href = library_instance.version_href
+          repository.version_prn = library_instance.version_prn
           repository.publication_href = library_instance.publication_href
-          if repository.deb_using_structured_apt?
+          repository.publication_prn = library_instance.publication_prn
+          if repository.deb?
             repository.content_id = library_instance.content_id
           end
           repository.save!
@@ -33,6 +37,7 @@ module Actions
         def finalize
           repository = ::Katello::Repository.find(input[:repository_id])
           repository.clear_smart_proxy_sync_histories if input[:contents_changed]
+          schedule_async_repository_proxy_sync(repository)
         end
       end
     end

data/app/lib/actions/katello/content_view/remove_rolling_repo_clone.rb

@@ -2,21 +2,26 @@ module Actions
   module Katello
     module ContentView
       class RemoveRollingRepoClone < Actions::EntryAction
-        def plan(content_view, repository_ids)
-          library = content_view.organization.library
+        def plan(content_view, repository_ids, environment_ids)
+          clone_ids = []
+          environments = ::Katello::KTEnvironment.where(id: environment_ids)
+          repositories = ::Katello::Repository.where(id: repository_ids)
 
-          clone_repo_ids = []
-          concurrence do
-            ::Katello::Repository.where(id: repository_ids).each do |repository|
-              clone_repo = content_view.get_repo_clone(library, repository).first
-              next if clone_repo.nil?
+          sequence do
+            environments.each do |environment|
+              concurrence do
+                repositories.each do |repository|
+                  clone_repo = content_view.get_repo_clone(environment, repository).first
+                  next if clone_repo.nil?
 
-              clone_repo_ids << clone_repo.id
-              plan_action(Actions::Pulp3::Repository::DeleteDistributions, clone_repo.id, SmartProxy.pulp_primary)
+                  clone_ids << clone_repo.id
+                  plan_action(Actions::Pulp3::Repository::DeleteDistributions, clone_repo.id, SmartProxy.pulp_primary)
+                end
+                plan_action(Candlepin::Environment::SetContent, content_view, environment, content_view.content_view_environment(environment))
+              end
             end
-            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library))
+            plan_self(repository_ids: clone_ids)
           end
-          plan_self(repository_ids: clone_repo_ids)
         end
 
         def run

data/app/lib/actions/katello/content_view/update.rb

@@ -2,7 +2,7 @@ module Actions
   module Katello
     module ContentView
       class Update < Actions::EntryAction
-        def plan(content_view, content_view_params)
+        def plan(content_view, content_view_params, environment_ids)
           action_subject content_view
           content_view_params = content_view_params.with_indifferent_access
 
@@ -28,15 +28,42 @@ module Actions
             end
           end
 
-          if content_view.rolling? && content_view_params.key?(:repository_ids)
-            repo_ids_to_add = content_view_params[:repository_ids] - content_view.repository_ids
-            repo_ids_to_remove = content_view.repository_ids - content_view_params[:repository_ids]
+          handle_rolling_content_view(content_view, content_view_params[:repository_ids], environment_ids)
+          content_view.update!(content_view_params)
+        end
 
-            plan_action(AddRollingRepoClone, content_view, repo_ids_to_add) if repo_ids_to_add.any?
-            plan_action(RemoveRollingRepoClone, content_view, repo_ids_to_remove) if repo_ids_to_remove.any?
+        def handle_rolling_content_view(content_view, target_repo_ids, target_env_ids)
+          return unless content_view.rolling?
+
+          add_repo_ids, remove_repo_ids, retain_repo_ids = translate_id_lists(content_view.repository_ids, target_repo_ids)
+
+          if target_env_ids.nil?
+            target_env_ids = retain_env_ids = content_view.environment_ids
+          else
+            add_env_ids, remove_env_ids, retain_env_ids = translate_id_lists(content_view.environment_ids, target_env_ids)
+            ::Katello::KTEnvironment.where(id: add_env_ids).each do |environment|
+              plan_action(AddToEnvironment, content_view.versions[0], environment)
+            end
+            plan_action(AddRollingRepoClone, content_view, retain_repo_ids, add_env_ids) if retain_repo_ids.any? && add_env_ids.any?
+            ::Katello::KTEnvironment.where(id: remove_env_ids).each do |environment|
+              plan_action(RemoveFromEnvironment, content_view, environment)
+            end
           end
 
-          content_view.update!(content_view_params)
+          plan_action(AddRollingRepoClone, content_view, add_repo_ids, target_env_ids) if add_repo_ids.any?
+          plan_action(RemoveRollingRepoClone, content_view, remove_repo_ids, retain_env_ids) if remove_repo_ids.any?
+        end
+
+        def translate_id_lists(current_ids, target_ids)
+          if target_ids.nil?
+            add_ids = remove_ids = []
+            retain_ids = current_ids
+          else
+            add_ids = target_ids - current_ids
+            remove_ids = current_ids - target_ids
+            retain_ids = current_ids - remove_ids
+          end
+          return add_ids, remove_ids, retain_ids
         end
       end
     end

data/app/lib/actions/katello/product/content_create.rb

@@ -7,7 +7,7 @@ module Actions
         def plan(repository)
           root = repository.root
           sequence do
-            if repository.content_id.nil? || repository.content_id == 'INITIAL_DUMMY_VALUE'
+            if repository.content_id.nil?
               content_create = plan_action(Candlepin::Product::ContentCreate,
                                            repository_id: repository.id,
                                            owner:         root.organization.label,
@@ -45,7 +45,7 @@ module Actions
         def finalize
           root = ::Katello::RootRepository.find(input[:root_repository_id])
           content_url = root.custom_content_path
-          if root.deb_using_structured_apt?
+          if root.deb?
             repository = ::Katello::Repository.find(input[:repository_id])
             content_url += repository.deb_content_url_options
             repository.update(:content_id => input[:content_id])

data/app/lib/actions/katello/product/content_destroy.rb

@@ -15,7 +15,7 @@ module Actions
             ::Katello::ProductContent.where(product_id: root_repository.product_id,
                                             content_id: katello_content_id).destroy_all
 
-            if root_repository.repositories.count <= 1 || repository.deb_using_structured_apt?
+            if root_repository.repositories.count <= 1 || repository.deb?
               plan_action(Candlepin::Product::ContentDestroy,
                           owner: root_repository.product.organization.label,
                           content_id: repository.content_id)

data/app/lib/actions/katello/repository/check_matching_content.rb

@@ -27,7 +27,7 @@ module Actions
             output[:matching_content] = srpms_match && rpms && errata && package_groups && distributions && target_repo_published && checksum_match
           end
 
-          if source_repo.content_type == ::Katello::Repository::DEB_TYPE
+          if source_repo.deb?
             debs = debs_match?(source_repo, target_repo)
 
             output[:matching_content] = debs && target_repo_published

data/app/lib/actions/katello/repository/clone_contents.rb

@@ -26,7 +26,7 @@ module Actions
             index_options = {id: new_repository.id, force_index: true}
             index_options[:source_repository_id] = source_repositories.first.id if source_repositories.count == 1 && filters.empty? && rpm_filenames.nil?
 
-            if new_repository.deb_using_structured_apt? && generate_metadata
+            if new_repository.deb? && generate_metadata
               plan_action(Candlepin::Product::ContentUpdate,
                           owner:           new_repository.organization.label,
                           repository_id:   new_repository.id,

data/app/lib/actions/katello/repository/create.rb

@@ -64,7 +64,7 @@ module Actions
         end
 
         def create_content?(repository, clone)
-          if repository.deb_using_structured_apt?
+          if repository.deb?
             return true
           elsif clone || repository.content
             return false

data/app/lib/actions/katello/repository/destroy.rb

@@ -86,10 +86,10 @@ module Actions
         end
 
         def handle_custom_content(repository, remove_from_content_view_versions)
-          #if this is the last instance of a custom repo or a deb repo using structured APT, destroy the content
-          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty? || repository.deb_using_structured_apt?
-            # Never destroy content for structured apt rolling repo clones, because it belongs to the library instance
-            return if repository.deb_using_structured_apt? && repository.content_view.rolling?
+          # If this is the last instance of a custom repo or a deb repo, then destroy the content
+          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty? || repository.deb?
+            # Never destroy content for deb rolling repo clones, it belongs to the library instance!
+            return if repository.deb? && repository.content_view.rolling?
 
             plan_action(::Actions::Katello::Product::ContentDestroy, repository)
           end

data/app/lib/actions/katello/repository/finish_upload.rb

@@ -15,7 +15,7 @@ module Actions
           generate_metadata = options.fetch(:generate_metadata, true)
           plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => import_upload_task, :force_publication => true) if generate_metadata
 
-          if repository.deb_using_structured_apt? && generate_metadata
+          if repository.deb? && generate_metadata
             plan_action(::Actions::Candlepin::Product::ContentUpdate,
                         owner:           repository.organization.label,
                         repository_id:   repository.id,

data/app/lib/actions/katello/repository/sync.rb

@@ -101,7 +101,7 @@ module Actions
         end
 
         def update_deb_content(repo)
-          return unless repo.deb_using_structured_apt?
+          return unless repo.deb?
 
           plan_action(::Actions::Candlepin::Product::ContentUpdate,
                       owner:           repo.organization.label,

data/app/lib/actions/pulp3/orchestration/repository/copy_all_units.rb

@@ -39,7 +39,7 @@ module Actions
             else
               plan_self(source_version_repo_id: source_repositories.first.id,
                         target_repo_id: target_repo.id)
-              target_repo.update!(version_href: source_repositories.first.version_href)
+              target_repo.update!(version_href: source_repositories.first.version_href, version_prn: source_repositories.first.version_prn)
             end
           end
 
@@ -47,7 +47,7 @@ module Actions
             #this is a 'simple' copy, so just reference version_href
             target_repo = ::Katello::Repository.find(input[:target_repo_id])
             source_repo = ::Katello::Repository.find(input[:source_version_repo_id])
-            target_repo.update!(version_href: source_repo.version_href)
+            target_repo.update!(version_href: source_repo.version_href, version_prn: source_repo.version_prn)
           end
         end
       end

data/app/lib/actions/pulp3/orchestration/repository/generate_metadata.rb

@@ -33,7 +33,7 @@ module Actions
               if (target_repo.publication_href != source_repo.publication_href && smart_proxy.pulp_primary?)
                 target_repo.clear_smart_proxy_sync_histories
               end
-              target_repo.update!(publication_href: source_repo.publication_href)
+              target_repo.update!(publication_href: source_repo.publication_href, publication_prn: source_repo.publication_prn)
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/repository/multi_copy_all_units.rb

@@ -31,7 +31,7 @@ module Actions
             input[:repo_id_map].each do |source_repo_id, dest_repo_id|
               dest_repo = ::Katello::Repository.find(dest_repo_id)
               source_repo = ::Katello::Repository.find(source_repo_id)
-              dest_repo.update!(version_href: source_repo.version_href)
+              dest_repo.update!(version_href: source_repo.version_href, version_prn: source_repo.version_prn)
             end
           end
         end

data/app/lib/actions/pulp3/repository/save_publication.rb

@@ -12,7 +12,9 @@ module Actions
             publication_href = input[:tasks][:pulp_tasks].first[:created_resources].first
             if publication_href
               repo = ::Katello::Repository.find(input[:repository_id])
-              repo.update(:publication_href => publication_href)
+              repo_backend_service = repo.backend_service(SmartProxy.pulp_primary)
+              publication = repo_backend_service.api.publications_api.read(publication_href, {fields: 'prn'})
+              repo.update(:publication_href => publication_href, :publication_prn => publication.prn)
             end
           end
         end

data/app/lib/actions/pulp3/repository/save_version.rb

@@ -9,35 +9,56 @@ module Actions
 
         def run
           repo = ::Katello::Repository.find(input[:repository_id])
-          if input[:force_fetch_version]
-            version_href = fetch_version_href(repo)
-          elsif input[:repository_details].present?
-            version_href = input[:repository_details][:latest_version_href]
-          elsif input[:tasks].present?
-            version_href = ::Katello::Pulp3::Task.version_href(input[:tasks])
-          else
-            version_href = fetch_version_href(repo)
-          end
+          version_href = determine_version_href(repo)
+
+          save_publication_if_present(repo)
+          save_version_if_changed(repo, version_href)
+        end
+
+        def determine_version_href(repo)
+          return fetch_version_href(repo) if input[:force_fetch_version]
+          return input[:repository_details][:latest_version_href] if input[:repository_details].present?
+          return ::Katello::Pulp3::Task.version_href(input[:tasks]) if input[:tasks].present?
+          fetch_version_href(repo)
+        end
 
+        def save_publication_if_present(repo)
           output[:publication_provided] = false
-          if input[:tasks].present? && (publication_href = ::Katello::Pulp3::Task.publication_href(input[:tasks]))
-            repo.update(:publication_href => publication_href)
-            output[:publication_provided] = true
-          end
+          return if input[:tasks].blank?
+
+          publication_href = ::Katello::Pulp3::Task.publication_href(input[:tasks])
+          return unless publication_href
 
+          repo_backend_service = repo.backend_service(SmartProxy.pulp_primary)
+          publication = repo_backend_service.api.publications_api.read(publication_href, {fields: 'prn'})
+          repo.update(:publication_href => publication_href, :publication_prn => publication.prn)
+          output[:publication_provided] = true
+        end
+
+        def save_version_if_changed(repo, version_href)
           if version_href
-            if repo.version_href != version_href || input[:force_fetch_version]
-              output[:contents_changed] = true
-              repo.update(:last_contents_changed => DateTime.now)
-              repo.update(:version_href => version_href)
-            end
+            update_version_if_changed(repo, version_href)
+          else
+            check_publication_version_match(repo)
+          end
+        end
+
+        def update_version_if_changed(repo, version_href)
+          return unless repo.version_href != version_href || input[:force_fetch_version]
+
+          output[:contents_changed] = true
+          repo.update(:last_contents_changed => DateTime.now)
+          repo_backend_service = repo.backend_service(SmartProxy.pulp_primary)
+          version = repo_backend_service.api.repository_versions_api.read(version_href, {fields: 'prn'})
+          repo.update(:version_href => version_href, :version_prn => version.prn)
+        end
+
+        def check_publication_version_match(repo)
+          # get publication and check if repo-version and publication match. Otherwise, contents_changed: false
+          if !repo.repository_type.pulp3_skip_publication && fetch_current_published_version_href(repo) != repo.version_href
+            output[:contents_changed] = true
           else
-            # get publication and check if repo-version and publication match. Otherwise, contents_changed: false
-            if !repo.repository_type.pulp3_skip_publication && fetch_current_published_version_href(repo) != repo.version_href
-              output[:contents_changed] = true
-            else
-              output[:contents_changed] = false
-            end
+            output[:contents_changed] = false
           end
         end
 

data/app/lib/actions/pulp3/repository/save_versions.rb

@@ -37,7 +37,8 @@ module Actions
             end
 
             unless new_version_href == repo.version_href
-              repo.update(version_href: new_version_href)
+              version = repo_backend_service.api.repository_versions_api.read(new_version_href, {fields: 'prn'})
+              repo.update(version_href: new_version_href, version_prn: version.prn)
               repo.index_content
               output[:contents_changed] = true
               output[:updated_repositories] << repo.id

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

@@ -10,11 +10,10 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access akeys
           end
 
-          def create(name, owner_key, auto_attach, service_level, release_version, purpose_role, purpose_usage)
+          def create(name, owner_key, service_level, release_version, purpose_role, purpose_usage)
             url = "/candlepin/owners/#{owner_key}/activation_keys"
             params = {
               name: name,
-              autoAttach: auto_attach,
               serviceLevel: service_level,
               releaseVer: release_version,
               role: purpose_role,
@@ -24,8 +23,8 @@ module Katello
             JSON.parse(response.body).with_indifferent_access
           end
 
-          def update(id, release_version, service_level, auto_attach, purpose_role, purpose_usage)
-            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :autoAttach => auto_attach, :role => purpose_role, :usage => purpose_usage }.delete_if { |_k, v| v.nil? }
+          def update(id, release_version, service_level, purpose_role, purpose_usage)
+            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :role => purpose_role, :usage => purpose_usage }.delete_if { |_k, v| v.nil? }
             JSON.parse(self.put(path(id), attrs.to_json, self.default_headers).body).with_indifferent_access
           end
 

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

@@ -5,13 +5,14 @@ module Katello
         class << self
           NOT_FINISHED_STATES = %w(CREATED WAITING PENDING RUNNING).freeze unless defined? NOT_FINISHED_STATES
           API_URL = 'https://subscription.rhsm.redhat.com/subscription'.freeze
+          SUBSCRIPTION_PATH = '/subscription'.freeze
 
           def not_finished?(job)
             NOT_FINISHED_STATES.include?(job[:state])
           end
 
           def get(id, upstream)
-            url = ENV['REDHAT_RHSM_API_URL'] || API_URL
+            url = subscription_path(ENV['REDHAT_RHSM_API_URL']) || subscription_path(upstream['apiUrl']) || API_URL
             response = Resources::Candlepin::UpstreamConsumer.start_upstream_export("#{url}#{path(id)}", upstream['idCert']['cert'],
               upstream['idCert']['key'], nil)
             job = JSON.parse(response)
@@ -21,6 +22,13 @@ module Katello
           def path(id = nil)
             "/jobs/#{id}"
           end
+
+          def subscription_path(upstream_api_url)
+            return if upstream_api_url.blank?
+            uri = URI.parse(upstream_api_url) # https://subscription.rhsm.redhat.com/subscription/consumers/
+            uri.path = SUBSCRIPTION_PATH # https://subscription.rhsm.redhat.com/subscription
+            uri.to_s
+          end
         end
       end
     end

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

@@ -88,6 +88,10 @@ module Katello
         class << self
           delegate :[], to: :json_resource
 
+          def default_headers(uuid = nil)
+            super(uuid).except('cp-user', 'cp-consumer')
+          end
+
           def resource(options = {}, url: self.site + self.path, client_cert: self.client_cert, client_key: self.client_key, ca_file: nil)
             cert_store = OpenSSL::X509::Store.new
             cert_store.add_file(ca_file) if ca_file

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

@@ -39,14 +39,27 @@ module Katello
 
       def readable_docker_catalog(host = nil)
         if host
-          repo_ids = nil
+          repo_ids = []
           if host&.content_view_environments&.any?
             repo_ids = host.content_view_environments.flat_map do |cve|
-              cve&.content_view_version&.repositories&.where(environment_id: cve.environment)&.non_archived&.docker_type&.pluck(:id)
+              cve&.content_view_version&.repositories&.where(environment_id: cve.environment)&.pluck(:id)
             end
+            repo_ids = repo_ids.compact.uniq
+          end
+
+          base_scope = Katello::Repository.non_archived.docker_type
+          host_repos = base_scope.where(id: repo_ids)
+
+          table_name = Repository.table_name
+          in_unauth_environments = Repository.joins(:environment)
+                                             .where("#{Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true)
+                                             .select(:id)
+
+          if in_unauth_environments.exists?
+            return host_repos.or(base_scope.joins(:root).where("#{table_name}.id in (?)", in_unauth_environments))
+          else
+            return host_repos
           end
-          repos = Katello::Repository.where(id: repo_ids)
-          return repos
         end
         readable_docker_catalog_as(User.current)
       end

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

@@ -21,7 +21,6 @@ module Katello
         scoped_search on: :status, relation: :rhel_lifecycle_status_object, rename: :rhel_lifecycle_status, complete_value: rhel_lifecycle_status_map
 
         scoped_search :on => :release_version, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
-        scoped_search :on => :autoheal, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :service_level, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :last_checkin, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :registered_through, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
@@ -45,8 +44,6 @@ module Katello
         content_facet.cves_changed = false if content_facet
         content_facet&.save!
 
-        auto_attach_enabled_via_checkin = consumer_params.try(:[], 'autoheal')
-
         if subscription_facet
           consumer_params ||= subscription_facet.consumer_attributes
 
@@ -59,10 +56,6 @@ module Katello
           end
           ::Katello::Resources::Candlepin::Consumer.update(subscription_facet.uuid, consumer_params)
 
-          if auto_attach_enabled_via_checkin
-            ::Katello::Resources::Candlepin::Consumer.refresh_entitlements(subscription_facet.uuid)
-          end
-
           if consumer_params.try(:[], :facts)
             ::Katello::Host::SubscriptionFacet.update_facts(self, consumer_params[:facts])
           end

data/app/models/katello/content_view_deb_filter.rb

@@ -13,6 +13,8 @@ module Katello
         package_filenames.concat(query_debs(repo, rule))
       end
 
+      package_filenames = package_filenames.uniq.sort
+
       ContentViewDebFilter.generate_deb_clauses(package_filenames)
     end
 
@@ -21,6 +23,9 @@ module Katello
       self.deb_rules.each do |rule|
         deb_filenames.concat(query_debs(repo, rule))
       end
+
+      deb_filenames = deb_filenames.uniq
+
       debs = Deb.in_repositories(repo)
       debs.where(filename: deb_filenames).pluck(:pulp_id).flatten.uniq
     end
@@ -45,6 +50,11 @@ module Katello
         query_arch = rule.architecture.tr("*", "%")
         query = query.where("#{Deb.table_name}.architecture ilike ?", query_arch)
       end
+      if rule.version.present?
+        query = query.search_version_equal(rule.version)
+      elsif rule.min_version.present? || rule.max_version.present?
+        query = query.search_version_range(rule.min_version, rule.max_version)
+      end
       query.default_sort
     end
   end

data/app/models/katello/content_view_deb_filter_rule.rb

@@ -10,10 +10,17 @@ module Katello
     validates :name, :presence => true
     validate :ensure_unique_attributes
     validates_with Validators::ContentViewFilterVersionValidator
+    scoped_search :on => :version, :complete_value => true
+    scoped_search :on => :min_version, :complete_value => true
+    scoped_search :on => :max_version, :complete_value => true
+    scoped_search :on => :architecture, :complete_value => true
 
     def ensure_unique_attributes
       other = self.class.where(:name => self.name,
+                               :version => self.version,
                                :content_view_filter_id => self.content_view_filter_id,
+                               :min_version => self.min_version,
+                               :max_version => self.max_version,
                                :architecture => self.architecture)
       other = other.where.not(:id => self.id) if self.id
       if other.exists?