katello 4.18.1 → 4.19.0.rc1

data/app/controllers/katello/api/v2/content_view_filter_rules_controller.rb

@@ -95,7 +95,7 @@ module Katello
       update_params = rule_params
       update_params[:name] = update_params[:name].first if update_params[:name]
 
-      if @rule.filter.content_type == ContentViewPackageFilter::CONTENT_TYPE
+      if [ContentViewPackageFilter::CONTENT_TYPE, ContentViewDebFilter::CONTENT_TYPE].include?(@rule.filter.content_type)
         update_params[:version] = "" unless rule_params[:version]
         update_params[:min_version] = "" unless rule_params[:min_version]
         update_params[:max_version] = "" unless rule_params[:max_version]

data/app/controllers/katello/api/v2/content_views_controller.rb

@@ -21,6 +21,7 @@ module Katello
       param :description, String, :desc => N_("Description for the content view")
       param :repository_ids, Array, :desc => N_("List of repository ids")
       param :component_ids, Array, :desc => N_("List of component content view version ids for composite views")
+      param :environment_ids, Array, :desc => N_("List of lifecycle environments for rolling content views")
       param :auto_publish, :bool, :desc => N_("Enable/Disable auto publish of composite view")
       param :solve_dependencies, :bool, :desc => N_("Solve RPM dependencies by default on Content View publish, defaults to false")
       param :import_only, :bool, :desc => N_("Designate this Content View for importing from upstream servers only. Defaults to false")
@@ -42,6 +43,7 @@ module Katello
       {
         :component_ids => Katello::ContentViewVersion,
         :repository_ids => Katello::Repository,
+        :environment_ids => Katello::KTEnvironment,
       }
     end
 
@@ -87,11 +89,12 @@ module Katello
     param :rolling, :bool, :desc => N_("Rolling content view")
     param_group :content_view
     def create
+      validate_environment_ids!(params[:rolling])
       @content_view = ContentView.create!(view_params) do |view|
         view.organization = @organization
         view.label ||= labelize_params(params[:content_view])
       end
-      sync_task(::Actions::Katello::ContentView::Create, @content_view)
+      sync_task(::Actions::Katello::ContentView::Create, @content_view, sanitized_environment_ids)
 
       respond :resource => @content_view
     end
@@ -101,7 +104,8 @@ module Katello
     param :name, String, :desc => N_("New name for the content view")
     param_group :content_view
     def update
-      sync_task(::Actions::Katello::ContentView::Update, @content_view, view_params)
+      validate_environment_ids!(@content_view.rolling?)
+      sync_task(::Actions::Katello::ContentView::Update, @content_view, view_params, sanitized_environment_ids)
       respond :resource => @content_view.reload
     end
 
@@ -299,12 +303,23 @@ module Katello
       if (!@content_view || !@content_view.composite?)
         attrs.push({:repository_ids => []}, :repository_ids)
       end
-      result = params.require(:content_view).permit(*attrs).to_h
+      result = {}
+      result = params.require(:content_view).permit(*attrs).to_h unless action_name == "update" && @content_view.rolling? && params[:content_view].empty?
       # sanitize repository_ids to be a list of integers
       result[:repository_ids] = result[:repository_ids].compact.map(&:to_i) if result[:repository_ids].present?
       result
     end
 
+    def sanitized_environment_ids
+      params[:environment_ids]&.compact&.map(&:to_i)
+    end
+
+    def validate_environment_ids!(rolling)
+      if params[:environment_ids] && !rolling
+        fail HttpErrors::BadRequest, _("It's not possible to provide environment_ids for anything other than a rolling content view.")
+      end
+    end
+
     def find_environment
       return if !params.key?(:environment_id) && params[:action] == "index"
       @environment = KTEnvironment.readable.find(params[:environment_id])

data/app/controllers/katello/api/v2/debs_controller.rb

@@ -13,15 +13,15 @@ module Katello
     def auto_complete(search)
       page_size = Katello::Concerns::FilteredAutoCompleteSearch::PAGE_SIZE
       debs = Deb.in_repositories(@repositories)
-      col = ''
-      case search
-      when 'name'
-        col = "#{Deb.table_name}.name"
-      when 'arch'
-        col = "#{Deb.table_name}.architecture"
-      end
-      debs = debs.where("#{col} ILIKE ?", "#{params[:term]}%").select(col).group(col).order(col).limit(page_size)
-      render :json => debs.pluck(col)
+      col = case search
+            when 'name' then "#{Deb.table_name}.name"
+            when 'arch' then "#{Deb.table_name}.architecture"
+            end
+      return render json: [] if col.blank?
+
+      scope = debs.select(col).group(col).order(col).limit(page_size)
+      scope = scope.where("#{col} ILIKE ?", "%#{params[:term]}%") if params[:term].present?
+      render json: scope.pluck(Arel.sql(col))
     end
 
     def auto_complete_name
@@ -29,7 +29,7 @@ module Katello
     end
 
     def auto_complete_arch
-      auto_complete('architecture')
+      auto_complete('arch')
     end
 
     api :GET, "/debs", N_("List deb packages")
@@ -52,6 +52,16 @@ module Katello
       super
     end
 
+    def thindex
+      sort_by, sort_order, options = sort_options
+
+      options[:select] = "DISTINCT ON (#{Deb.table_name}.name) #{Deb.table_name}.id, #{Deb.table_name}.name"
+      final_relation = custom_index_relation(Deb.all)
+
+      result = scoped_search(final_relation, sort_by, sort_order, options)
+      respond_for_index(:collection => result, :template => "thindex")
+    end
+
     def final_custom_index_relation(collection)
       # :packages_restrict_latest is intended to filter the result set after all
       # other constraints have been applied, including the scoped_search
@@ -95,7 +105,7 @@ module Katello
         collection = collection.installable_for_hosts(@hosts)
       elsif not_installed && params[:host_id]
         host = @hosts.first
-        collection = Katello::Deb.apt_installable_for_host(host)
+        collection = Katello::Deb.deb_installable_for_host(host)
       elsif applicable
         collection = collection.applicable_to_hosts(@hosts)
       end

data/app/controllers/katello/api/v2/docker_tags_controller.rb

@@ -46,6 +46,13 @@ module Katello
 
     private
 
+    def custom_index_relation(collection)
+      collection.includes(
+        schema1: { docker_taggable: :docker_manifests },
+        schema2: { docker_taggable: :docker_manifests }
+      )
+    end
+
     def find_repositories
       @repositories = Repository.readable.where(:id => params[:repoids])
     end

data/app/controllers/katello/api/v2/flatpak_remote_repositories_controller.rb

@@ -4,7 +4,7 @@ module Katello
 
     before_action :find_remote_repository, :except => [:index, :auto_complete_search]
     before_action :find_optional_organization, :only => [:index, :auto_complete_search]
-    before_action :find_product, :only => [:mirror]
+    before_action :find_and_validate_product_for_mirroring, :only => [:mirror]
 
     resource_description do
       name 'Flatpak Remote Repositories'
@@ -56,7 +56,6 @@ module Katello
     param :product_name, String, :desc => N_("Name of the product to mirror the remote repository to")
     param :organization_id, :number, :desc => N_("organization identifier")
     def mirror
-      validate_product_for_mirroring
       task = async_task(::Actions::Katello::Flatpak::MirrorRemoteRepository, @flatpak_remote_repository, @product)
       respond_for_async :resource => task
     end
@@ -75,10 +74,17 @@ module Katello
       @flatpak_remote_repository
     end
 
-    def find_product
+    protected
+
+    def rejected_autocomplete_items
+      ['flatpak_remote_id', 'flatpak_remote']
+    end
+
+    private
+
+    def find_and_validate_product_for_mirroring
       if params[:product_id]
-        @product = Product.editable.find(params[:product_id])
-        throw_resource_not_found(name: 'product', id: params[:product_id]) unless @product
+        @product = Product.editable.find(params[:product_id]) # will throw not found if id is invalid
       elsif params[:product_name] && params[:organization_id]
         @product = Product.editable.find_by(name: params[:product_name], organization_id: params[:organization_id])
         unless @product
@@ -86,22 +92,18 @@ module Katello
                   { name: params[:product_name], org_id: params[:organization_id] }
           fail HttpErrors::NotFound, msg
         end
+      elsif params[:product_name]
+        msg = _("Organization must be specified when providing product by name.")
+        fail HttpErrors::BadRequest, msg
+      else
+        msg = _("Product must be specified.")
+        fail HttpErrors::BadRequest, msg
       end
-      @product
-    end
 
-    protected
-
-    def rejected_autocomplete_items
-      ['flatpak_remote_id', 'flatpak_remote']
-    end
-
-    private
-
-    def validate_product_for_mirroring
-      return unless @product&.redhat?
-      msg = _("Flatpak repositories cannot be mirrored into Red Hat products. Please select a custom product.")
-      fail HttpErrors::UnprocessableEntity, msg
+      if @product.redhat?
+        msg = _("Flatpak repositories cannot be mirrored into Red Hat products. Please select a custom product.")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
     end
   end
 end

data/app/controllers/katello/api/v2/host_debs_controller.rb

@@ -1,14 +1,29 @@
 module Katello
   class Api::V2::HostDebsController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
+    include Katello::Concerns::Api::V2::RepositoryContentController
 
-    before_action :find_host
+    before_action :find_host, only: [:index]
 
     resource_description do
       api_version 'v2'
       api_base_url "/api"
     end
 
+    api :GET, "/host_debs/installed_debs", N_("Return a list of installed debs distinct by name")
+    param_group :search, ::Katello::Api::V2::ApiController
+    def installed_debs
+      _sort_by, _sort_order, options = sort_options
+      sort_by = 'name'
+      sort_order = 'asc'
+
+      options[:select] = "DISTINCT ON (#{::Katello::InstalledDeb.table_name}.name) #{::Katello::InstalledDeb.table_name}.id, #{::Katello::InstalledDeb.table_name}.name"
+      final_relation = ::Katello::InstalledDeb.all
+
+      result = scoped_search(final_relation, sort_by, sort_order, options)
+      respond_for_index(:collection => result, :template => "installed_debs")
+    end
+
     api :GET, "/hosts/:host_id/debs", N_("List deb packages installed on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :include_latest_upgradable, :boolean, :desc => N_("Also include the latest upgradable package version for each host package")

data/app/controllers/katello/api/v2/host_subscriptions_controller.rb

@@ -2,7 +2,6 @@ module Katello
   class Api::V2::HostSubscriptionsController < Katello::Api::V2::ApiController
     include Katello::Concerns::Api::V2::ContentOverridesController
     before_action :find_host, :except => :create
-    before_action :check_subscriptions, :only => [:add_subscriptions, :remove_subscriptions]
     before_action :find_content_view_environment, :only => :create
     before_action :check_registration_services, :only => [:destroy, :create]
     before_action :find_content_overrides, :only => [:content_override]
@@ -17,10 +16,9 @@ module Katello
 
     def_param_group :subscription_facet_attributes do
       param :release_version, String, :desc => N_("Release version for this Host to use (7Server, 7.1, etc)")
-      param :autoheal, :bool, :desc => N_("Sets whether the Host will autoheal subscriptions upon checkin")
       param :purpose_usage, String, :desc => N_("Sets the system purpose usage")
       param :purpose_role, String, :desc => N_("Sets the system purpose usage")
-      param :service_level, String, :desc => N_("Service level to be used for autoheal")
+      param :service_level, String, :desc => N_("Service level")
       param :hypervisor_guest_uuids, Array, :desc => N_("List of hypervisor guest uuids")
       param :installed_products_attributes, Array, :desc => N_("List of products installed on the host") do
         param_group :installed_products, Api::V2::HostSubscriptionsController
@@ -51,18 +49,6 @@ module Katello
       full_result_response(presenter.subscriptions)
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions"), deprecated: true
-    param :host_id, Integer, :desc => N_("Id of the host"), :required => true
-    def auto_attach
-      deprecate_entitlement_mode_endpoint
-      if @host.organization.simple_content_access?
-        fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Auto-attach is disabled")
-      end
-
-      sync_task(::Actions::Katello::Host::AutoAttachSubscriptions, @host)
-      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
-    end
-
     api :DELETE, "/hosts/:host_id/subscriptions/", N_("Unregister the host as a subscription consumer")
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     def destroy
@@ -80,7 +66,7 @@ module Katello
       param_group :installed_products, ::Katello::Api::V2::HostSubscriptionsController
     end
     param :release_version, String, :desc => N_("Release version of the content host")
-    param :service_level, String, :desc => N_("A service level for auto-healing process, e.g. SELF-SUPPORT")
+    param :service_level, String, :desc => N_("Service level, e.g. SELF-SUPPORT")
     param :lifecycle_environment_id, Integer, :desc => N_("Lifecycle Environment ID"), :required => true
     param :content_view_id, Integer, :desc => N_("Content View ID"), :required => true
     def create
@@ -115,45 +101,6 @@ module Katello
       rhsm_params
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/remove_subscriptions", N_("Remove subscriptions from a host"), deprecated: true
-    param :host_id, Integer, :desc => N_("Id of the host"), :required => true
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, Integer, :desc => N_("If specified, remove the first instance of a subscription with matching id and quantity"), :required => false
-    end
-    def remove_subscriptions
-      deprecate_entitlement_mode_endpoint
-      #combine the quantities for duplicate pools into PoolWithQuantities objects
-      pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
-        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.with_identifier(subscription['id']))
-        new_hash[subscription['id']].quantities << subscription['quantity']
-        new_hash
-      end
-
-      sync_task(::Actions::Katello::Host::RemoveSubscriptions, @host, pool_id_quantities.values)
-      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
-    end
-
-    api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host"), deprecated: true
-    param :host_id, Integer, :desc => N_("Id of the host"), :required => true
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
-    end
-    def add_subscriptions
-      deprecate_entitlement_mode_endpoint
-      if @host.organization.simple_content_access?
-        fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Attaching subscriptions is disabled.")
-      end
-
-      pools_with_quantities = params.require(:subscriptions).map do |sub_params|
-        PoolWithQuantities.new(Pool.with_identifier(sub_params['id']), sub_params['quantity'].to_i)
-      end
-
-      sync_task(::Actions::Katello::Host::AttachSubscriptions, @host, pools_with_quantities)
-      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
-    end
-
     api :GET, "/hosts/:host_id/subscriptions/product_content", N_("Get content and overrides for the host")
     param :host_id, String, :desc => N_("Id of the host"), :required => true
     param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions")
@@ -215,10 +162,6 @@ module Katello
       fail HttpErrors::NotFound, _("Couldn't find specified content view and lifecycle environment.") if @content_view_environment.nil?
     end
 
-    def check_subscriptions
-      fail HttpErrors::BadRequest, _("subscriptions not specified") if params[:subscriptions].blank?
-    end
-
     def check_registration_services
       fail "Unable to register system, not all services available" unless Katello::RegistrationManager.check_registration_services
     end
@@ -228,7 +171,7 @@ module Katello
     end
 
     def action_permission
-      if ['add_subscriptions', 'destroy', 'remove_subscriptions', 'auto_attach', 'content_override'].include?(params[:action])
+      if ['destroy', 'content_override'].include?(params[:action])
         :edit
       elsif ['index', 'events', 'product_content', 'available_release_versions', 'enabled_repositories'].include?(params[:action])
         :view

data/app/controllers/katello/api/v2/hosts_bulk_actions_controller.rb

@@ -1,5 +1,6 @@
 module Katello
   # this is Katello's host bulk actions controller, not to be confused with Foreman's
+  # rubocop:disable Metrics/ClassLength
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include ::Api::V2::BulkHostsExtension
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -13,11 +14,8 @@ module Katello
     before_action :find_deletable_hosts, only: [:destroy_hosts]
     before_action :find_readable_hosts, only: [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, only: [:available_incremental_updates]
-    before_action :find_organization, only: [:add_subscriptions]
     before_action :find_traces, only: [:resolve_traces]
 
-    before_action :validate_organization, only: [:add_subscriptions]
-
     # disable *_count fields on erratum rabl, since they perform N+1 queries
     before_action :disable_erratum_hosts_count
 
@@ -51,8 +49,14 @@ module Katello
           host_collection.save!
 
           final_count = host_collection.host_ids.count - pre_host_collection_count
-          display_messages << _("Successfully added %{count} content host(s) to host collection %{host_collection}.") %
-              {:count => final_count, :host_collection => host_collection.name }
+          msg = if final_count == 0
+                  _("All selected hosts were already members of host collection %{host_collection}.") %
+                              {:host_collection => host_collection.name }
+                else
+                  _("Added %{count} host(s) to host collection %{host_collection}.") %
+                              {:count => final_count, :host_collection => host_collection.name }
+                end
+          display_messages << msg
         end
       end
 
@@ -74,7 +78,7 @@ module Katello
           host_collection.save!
 
           final_count = pre_host_collection_count - host_collection.host_ids.count
-          display_messages << _("Successfully removed %{count} content host(s) from host collection %{host_collection}.") %
+          display_messages << _("Removed %{count} host(s) from host collection %{host_collection}.") %
               {:count => final_count, :host_collection => host_collection.name }
         end
       end
@@ -106,49 +110,6 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts"), deprecated: true
-    param_group :bulk_params
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, Integer, :desc => N_("Quantity of specified subscription to remove"), :required => false
-    end
-    def remove_subscriptions
-      #combine the quantities for duplicate pools into PoolWithQuantities objects
-      pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
-        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.find(subscription['id']))
-        new_hash[subscription['id']].quantities << subscription['quantity']
-        new_hash
-      end
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::RemoveSubscriptions, @hosts, pool_id_quantities.values)
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts"), deprecated: true
-    param_group :bulk_params
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
-    end
-    def add_subscriptions
-      if @organization.simple_content_access?
-        fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
-      end
-
-      pools_with_quantities = params.require(:subscriptions).map do |sub_params|
-        PoolWithQuantities.new(Pool.find(sub_params['id']), sub_params['quantity'])
-      end
-
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AttachSubscriptions, @hosts, pools_with_quantities)
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts"), deprecated: true
-    param_group :bulk_params
-    def auto_attach
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AutoAttachSubscriptions, @hosts)
-      respond_for_async :resource => task
-    end
-
     api :PUT, "/hosts/bulk/content_overrides", N_("Set content overrides to one or more hosts")
     param_group :bulk_params
     param :content_overrides, Array, :desc => N_("Array of Content override parameters") do
@@ -310,10 +271,6 @@ module Katello
       find_bulk_hosts(:destroy_hosts, params)
     end
 
-    def validate_organization
-      fail HttpErrors::BadRequest, _("Organization ID is required") if @organization.blank?
-    end
-
     def validate_host_collection_membership_limit
       max_hosts_exceeded = []
       host_ids = @hosts.map(&:id)

data/app/controllers/katello/api/v2/repositories_controller.rb

@@ -676,7 +676,6 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
         root.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
         root.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
         root.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
-        root.content_id = 'INITIAL_DUMMY_VALUE' unless Setting['deb_enable_structured_apt']
       end
 
       if root.ansible_collection?

data/app/controllers/katello/concerns/organizations_controller_extensions.rb

@@ -24,6 +24,9 @@ module Katello
           if taxonomy_class == Organization
             begin
               @taxonomy = Organization.new(resource_params)
+              # Raise validation error early if invalid
+              @taxonomy.validate!
+
               ::Katello::OrganizationCreator.new(@taxonomy).create!
               @taxonomy.reload
               switch_taxonomy

data/app/lib/actions/candlepin/activation_key/create.rb

@@ -3,7 +3,6 @@ module Actions
     class ActivationKey::Create < Candlepin::Abstract
       input_format do
         param :organization_label
-        param :auto_attach
         param :service_level
         param :release_version
         param :purpose_role
@@ -13,7 +12,6 @@ module Actions
       def run
         output[:response] = ::Katello::Resources::Candlepin::ActivationKey.create(::Katello::Util::Model.uuid,
                                                                                   input[:organization_label],
-                                                                                  input[:auto_attach],
                                                                                   input[:service_level],
                                                                                   input[:release_version],
                                                                                   input[:purpose_role],

data/app/lib/actions/candlepin/activation_key/update.rb

@@ -6,7 +6,6 @@ module Actions
           param :cp_id
           param :release_version
           param :service_level
-          param :auto_attach
           param :purpose_role
           param :purpose_usage
         end
@@ -16,7 +15,6 @@ module Actions
                                                                 input[:cp_id],
                                                                 input[:release_version],
                                                                 input[:service_level],
-                                                                input[:auto_attach],
                                                                 input[:purpose_role],
                                                                 input[:purpose_usage])
         end

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

@@ -16,12 +16,10 @@ module Actions
         def run
           content_url = input[:content_url]
           if input[:type] == ::Katello::Repository::DEB_TYPE
-            # We must retrieve the repository in the run phase, so the latest Pulp version_href is
-            # already set. This is needed to retrieve the latest repository.deb_content_url_options!
+            # We must retrieve the deb? repository in the run phase, so the latest Pulp version_href
+            # is set. This is needed to retrieve the latest repository.deb_content_url_options!
             repository = ::Katello::Repository.find(input[:repository_id])
-            if repository.deb_using_structured_apt?
-              content_url += repository.deb_content_url_options
-            end
+            content_url += repository.deb_content_url_options
           end
 
           output[:response] = ::Katello::Resources::Candlepin::Content.

data/app/lib/actions/candlepin/product/content_update.rb

@@ -16,11 +16,10 @@ module Actions
         end
 
         def finalize
+          # finalize, because Katello::Product::ContentCreate updates repository.content_id during finalize!
           content_url = input[:content_url]
-          # We must retrieve the repository in the finalize phase, because Katello::Product::ContentCreate
-          # only updates the repository.content_id in the finalize phase!
           repository = ::Katello::Repository.find(input[:repository_id])
-          if repository.deb_using_structured_apt?
+          if repository.deb?
             content_url += repository.deb_content_url_options
           end
 

data/app/lib/actions/helpers/rolling_cv_repos.rb

@@ -2,7 +2,7 @@ module Actions
   module Helpers
     module RollingCVRepos
       def find_related_rolling_repos(repo)
-        repo.root.repositories.in_environment(repo.environment).where(
+        repo.root.repositories.where(
           content_view_version: ::Katello::ContentViewVersion.where(content_view: ::Katello::ContentView.rolling)
         )
       end

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

@@ -6,7 +6,6 @@ module Actions
           activation_key.save!
           cp_create = plan_action(Candlepin::ActivationKey::Create,
                                   organization_label: activation_key.organization.label,
-                                  auto_attach: activation_key.auto_attach,
                                   service_level: params[:service_level],
                                   release_version: activation_key.release_version,
                                   purpose_role: activation_key.purpose_role,

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

@@ -12,14 +12,12 @@ module Actions
                         cp_id: activation_key.cp_id,
                         release_version: activation_key.release_version,
                         service_level: activation_key.service_level,
-                        auto_attach: activation_key.auto_attach,
                         purpose_role: activation_key.purpose_role,
                         purpose_usage: activation_key.purpose_usage)
           end
         end
 
         def update_candlepin?(activation_key, activation_key_params)
-          cp_changed?(activation_key.auto_attach, activation_key_params[:auto_attach]) ||
           cp_changed?(activation_key.service_level, activation_key_params[:service_level]) ||
           cp_changed?(activation_key.release_version, activation_key_params[:release_version]) ||
           cp_changed?(activation_key.purpose_role, activation_key_params[:purpose_role]) ||

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module CapsuleContent
       class SyncCapsule < ::Actions::EntryAction
-        include Helpers::RollingCVRepos
         # rubocop:disable Metrics/MethodLength
         execution_plan_hooks.use :update_content_counts, :on => :success
         def plan(smart_proxy, options = {})
@@ -59,11 +58,7 @@ module Actions
           smart_proxy_helper.lifecycle_environment_check(environment, repository)
           if repository
             if skip_metatadata_check || !repository.smart_proxy_sync_histories.where(:smart_proxy_id => smart_proxy).any? { |sph| !sph.finished_at.nil? }
-              if repository.library_instance?
-                [repository] + find_related_rolling_repos(repository)
-              else
-                [repository]
-              end
+              [repository]
             end
           else
             repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count

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

@@ -6,7 +6,7 @@ module Actions
           action_subject gpg_key
           gpg_key.update!(gpg_key_params)
           gpg_key.repositories.each do |repository|
-            if repository.content_type == ::Katello::Repository::DEB_TYPE
+            if repository.deb?
               plan_action(::Actions::Katello::Repository::RefreshRepository, repository)
             end
           end