katello 3.17.3 → 3.18.0.rc1

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

@@ -37,7 +37,7 @@ module Katello
     before_action :find_organization, :only => [:create, :paths, :auto_complete_search]
     before_action :find_optional_organization, :only => [:index, :show, :update, :destroy]
     before_action :find_prior, :only => [:create]
-    before_action :find_environment, :only => [:show, :update, :destroy, :repositories]
+    before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy, :repositories]
     before_action :find_content_view, :only => [:repositories]
     before_action :find_path, :only => [:create]
 
@@ -154,16 +154,16 @@ module Katello
       respond_for_index(:collection => collection, :template => :paths)
     end
 
-    protected
+    def resource_name
+      'environment'
+    end
 
-    def find_environment
-      identifier = params.require(:id) || params.require(:environment).require(:id)
-      @environment = KTEnvironment.find(identifier)
-      fail HttpErrors::NotFound, _("Couldn't find environment '%s'") % identifier.to_s if @environment.nil?
-      @organization = @environment.organization
-      @environment
+    def resource_class
+      Katello::KTEnvironment
     end
 
+    protected
+
     def find_prior
       prior = params[:environment][:prior] || params.require(:environment).require(:prior_id)
       @prior = KTEnvironment.readable.find(prior)

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

@@ -52,13 +52,13 @@ module Katello
       respond_for_create(:resource => gpg_key)
     end
 
-    api :GET, "/gpg_keys/:id", N_("Show a gpg key")
+    api :GET, "/gpg_keys/:id", N_("Show a gpg key"), :deprecated => true
     param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
     def show
       respond_for_show(:resource => @gpg_key)
     end
 
-    api :PUT, "/gpg_keys/:id", N_("Update a repository")
+    api :PUT, "/gpg_keys/:id", N_("Update a repository"), :deprecated => true
     param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
     param_group :gpg_key
     def update
@@ -67,20 +67,20 @@ module Katello
       respond_for_show(:resource => @gpg_key)
     end
 
-    api :DELETE, "/gpg_keys/:id", N_("Destroy a gpg key")
+    api :DELETE, "/gpg_keys/:id", N_("Destroy a gpg key"), :deprecated => true
     param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
     def destroy
       @gpg_key.destroy
       respond_for_destroy
     end
 
-    api :GET, "/gpg_keys/:id/content", N_("Return the content of a gpg key, used directly by yum")
+    api :GET, "/gpg_keys/:id/content", N_("Return the content of a gpg key, used directly by yum"), :deprecated => true
     param :id, :number, :required => true
     def content
       render(:plain => @gpg_key.content, :layout => false)
     end
 
-    api :POST, "/gpg_keys/:id/content", N_("Upload gpg key contents")
+    api :POST, "/gpg_keys/:id/content", N_("Upload gpg key contents"), :deprecated => true
     param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
     param :content, File, :desc => N_("file contents"), :required => true
     def set_content

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

@@ -1,10 +1,17 @@
 module Katello
   class Api::V2::HostCollectionsController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
-    before_action :find_host_collection, :only => [:copy, :show, :update, :destroy,
-                                                   :add_hosts, :remove_hosts, :hosts]
-    before_action :find_activation_key
-    before_action :find_host
+    before_action :find_authorized_katello_resource, :only => [
+      :copy,
+      :show,
+      :update,
+      :destroy,
+      :add_hosts,
+      :remove_hosts,
+      :hosts
+    ]
+    before_action :find_readable_activation_key, :only => [:index]
+    before_action :find_editable_host, :only => [:index]
     before_action :find_optional_organization, :only => [:index]
     before_action :find_organization, :only => [:create, :auto_complete_search]
 
@@ -175,14 +182,6 @@ module Katello
 
     private
 
-    def find_host_collection
-      @organization = @host.organization if @host
-      @organization = @activation_key.organization if @activation_key
-      id = params[:host_collection_id] || params[:id]
-      @host_collection = HostCollection.where(:id => id).first
-      fail HttpErrors::NotFound, _("Couldn't find host collection '%s'") % id if @host_collection.nil?
-    end
-
     def host_collection_params
       attrs = [:name,
                :description,
@@ -199,14 +198,18 @@ module Katello
       result
     end
 
-    def find_host
+    def find_editable_host
       @host = resource_finder(::Host::Managed.authorized("edit_hosts"), params[:host_id]) if params[:host_id]
       @organization = @host.organization if @host
     end
 
-    def find_activation_key
-      @activation_key = ActivationKey.find_by!(:id => params[:activation_key_id]) if params[:activation_key_id]
-      @organization = @activation_key.organization if @activation_key
+    def find_readable_activation_key
+      @activation_key = ActivationKey.readable.find_by(:id => params[:activation_key_id]) if params[:activation_key_id]
+      if params[:activation_key_id] && @activation_key.nil?
+        throw_resource_not_found(name: 'activation_key', id: params[:activation_key_id])
+      else
+        @organization = @activation_key&.organization
+      end
     end
   end
 end

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

@@ -247,6 +247,23 @@ module Katello
       render json: result
     end
 
+    api :PUT, "/hosts/bulk/system_purpose", N_("Assign system purpose attributes on one or more hosts")
+    param_group :bulk_params
+    param :service_level, String, :desc => N_("Service level of host")
+    param :purpose_role, String, :desc => N_("Role of host")
+    param :purpose_usage, String, :desc => N_("Usage of host")
+    param :purpose_addons, Array, :desc => N_("Sets the system add-ons")
+    def system_purpose
+      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::UpdateSystemPurpose,
+        @hosts,
+        params[:service_level],
+        params[:purpose_role],
+        params[:purpose_usage],
+        params[:purpose_addons])
+
+      respond_for_async :resource => task
+    end
+
     api :POST, "/hosts/bulk/available_incremental_updates", N_("Given a set of hosts and errata, lists the content view versions" \
                                                                  " and environments that need updating.")
     param_group :bulk_params

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

@@ -62,7 +62,7 @@ module Katello
 
     def find_repositories
       params.require(:ids)
-      @repositories = Repository.where(:id => params[:ids])
+      @repositories = Repository.readable.where(:id => params[:ids])
     end
   end
 end

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

@@ -35,6 +35,8 @@ module Katello
 
     def_param_group :repo do
       param :url, String, :desc => N_("repository source url")
+      param :os_versions, Array,
+            :desc => N_("Identifies whether the repository should be disabled on a client with a non-matching OS version. Pass [] to enable regardless of OS version. Maximum length 1; allowed tags are: %s") % Katello::RootRepository::ALLOWED_OS_VERSIONS.join(', ')
       param :gpg_key_id, :number, :desc => N_("id of the gpg key that will be assigned to the new repository")
       param :ssl_ca_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL CA Cert")
       param :ssl_client_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Cert")
@@ -42,7 +44,7 @@ module Katello
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
       param :checksum_type, String, :desc => N_("Checksum of the repository, currently 'sha1' & 'sha256' are supported")
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
-      param :docker_tags_whitelist, Array, :desc => N_("Comma separated list of tags to sync for Container Image repository")
+      param :docker_tags_whitelist, Array, :desc => N_("Comma-separated list of tags to sync for Container Image repository")
       param :download_policy, ["immediate", "on_demand", "background"], :desc => N_("download policy for yum repos (either 'immediate', 'on_demand', or 'background (deprecated)')")
       param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
       param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed")
@@ -51,9 +53,9 @@ module Katello
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
       param :ostree_upstream_sync_policy, ::Katello::RootRepository::OSTREE_UPSTREAM_SYNC_POLICIES, :desc => N_("policies for syncing upstream ostree repositories")
       param :ostree_upstream_sync_depth, :number, :desc => N_("if a custom sync policy is chosen for ostree repositories then a 'depth' value must be provided")
-      param :deb_releases, String, :desc => N_("comma separated list of releases to be synched from deb-archive")
-      param :deb_components, String, :desc => N_("comma separated list of repo components to be synched from deb-archive")
-      param :deb_architectures, String, :desc => N_("comma separated list of architectures to be synched from deb-archive")
+      param :deb_releases, String, :desc => N_("comma-separated list of releases to be synced from deb-archive")
+      param :deb_components, String, :desc => N_("comma-separated list of repo components to be synced from deb-archive")
+      param :deb_architectures, String, :desc => N_("comma-separated list of architectures to be synced from deb-archive")
       param :ignore_global_proxy, :bool, :desc => N_("if true, will ignore the globally configured proxy when syncing"), :deprecated => true
       param :ignorable_content, Array, :desc => N_("List of content units to ignore while syncing a yum repository. Must be subset of %s") % RootRepository::IGNORABLE_CONTENT_UNIT_TYPES.join(",")
       param :ansible_collection_requirements, String, :desc => N_("Contents of requirement yaml file to sync from URL")
@@ -476,7 +478,7 @@ module Katello
 
     def repository_params
       keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username, :download_concurrency,
-              :ostree_upstream_sync_depth, :ostree_upstream_sync_policy,
+              :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, {:os_versions => []},
               :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy, :http_proxy_id,
               {:ignorable_content => []}
              ]
@@ -527,6 +529,7 @@ module Katello
       root.ansible_collection_requirements = repo_params[:ansible_collection_requirements] if root.ansible_collection?
       root.http_proxy_policy = repo_params[:http_proxy_policy] if repo_params.key?(:http_proxy_policy)
       root.http_proxy_id = repo_params[:http_proxy_id] if repo_params.key?(:http_proxy_id)
+      root.os_versions = repo_params.fetch(:os_versions, []) if root.yum?
 
       if root.ostree?
         root.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]

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

@@ -19,7 +19,7 @@ module Katello
 
     api :GET, "/organizations/:organization_id/subscriptions", N_("List organization subscriptions")
     api :GET, "/activation_keys/:activation_key_id/subscriptions", N_("List an activation key's subscriptions")
-    api :GET, "/subscriptions"
+    api :GET, "/subscriptions", N_("List subscriptions")
     param_group :search, Api::V2::ApiController
     param :organization_id, :number, :desc => N_("Organization ID"), :required => false
     param :host_id, String, :desc => N_("id of a host"), :required => false

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

@@ -4,8 +4,10 @@ module Katello
 
     include Katello::Concerns::FilteredAutoCompleteSearch
     before_action :find_organization, :only => [:create, :index, :auto_complete_search]
-    before_action :find_plan, :only => [:update, :show, :destroy, :sync,
-                                        :add_products, :remove_products]
+    before_action :find_authorized_katello_resource, :only => [:update, :show, :destroy, :sync,
+                                                               :add_products, :remove_products]
+    before_action :set_organization, :only => [:update, :show, :destroy, :sync,
+                                               :add_products, :remove_products]
 
     def_param_group :sync_plan do
       param :name, String, :desc => N_("sync plan name"), :required => true, :action_aware => true
@@ -117,16 +119,13 @@ module Katello
 
     protected
 
-    def find_plan
-      @sync_plan = SyncPlan.find_by(:id => params[:id])
-      fail HttpErrors::NotFound, _("Couldn't find sync plan '%{plan}' in organization '%{org}'") % { :plan => params[:id], :org => params[:organization_id] } if @sync_plan.nil?
-      @organization ||= @sync_plan.organization
-      @sync_plan
-    end
-
     def sync_plan_params
       params[:sync_plan][:enabled] = params[:enabled] unless params[:enabled].nil?
       params.require(:sync_plan).permit(:name, :description, :interval, :sync_date, :product_ids, :enabled, :cron_expression)
     end
+
+    def set_organization
+      @organization ||= @sync_plan.try(:organization)
+    end
   end
 end

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

@@ -77,7 +77,14 @@ module Katello
       render json: { status: 'OK' }
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/enable",
+    api :GET, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/eligible",
+      N_("Check if the specified organization is eligible for Simple Content Access")
+    def simple_content_access_eligible
+      eligible = @organization.upstream_consumer.simple_content_access_eligible?
+      render json: { simple_content_access_eligible: eligible }
+    end
+
+    api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/enable",
       N_("Enable simple content access for a manifest")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def enable_simple_content_access
@@ -85,7 +92,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/disable",
+    api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/disable",
       N_("Disable simple content access for a manifest")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def disable_simple_content_access

data/app/controllers/katello/concerns/api/v2/authorization.rb

@@ -21,12 +21,16 @@ module Katello
       end
 
       def find_authorized_katello_resource
-        finder_scope = ::Foreman::AccessControl.permissions_for_controller_action(path_to_authenticate).first&.finder_scope
-        if finder_scope
-          instance_variable_set("@#{resource_name}", resource_class.send(finder_scope).find_by(:id => params[:id]))
+        found_entity = nil
+        ::Foreman::AccessControl.permissions_for_controller_action(path_to_authenticate).each do |permission|
+          next unless found_entity.blank?
+          finder_scope = permission&.finder_scope
+          if finder_scope
+            found_entity = resource_class.send(finder_scope).find_by(:id => params[:id])
+          end
         end
-
-        throw_resource_not_found if instance_variable_get("@#{resource_name}").nil?
+        throw_resource_not_found if found_entity.blank?
+        instance_variable_set("@#{resource_name}", found_entity)
       end
 
       def find_unauthorized_katello_resource

data/app/controllers/katello/concerns/api/v2/registration_controller_extensions.rb

@@ -0,0 +1,21 @@
+module Katello
+  module Concerns
+    module Api::V2::RegistrationControllerExtensions
+      extend ActiveSupport::Concern
+
+      def prepare_host
+        if params['uuid']
+          @host = Katello::Host::SubscriptionFacet.find_by(uuid: params['uuid'])&.host
+          if @host.nil?
+            msg = N_("Host was not found by the subscription UUID: '%s', this can happen if the host is registered already, but not to this Foreman") % params['uuid']
+            fail ActiveRecord::RecordNotFound, msg
+          end
+          @host.assign_attributes(host_params('host'))
+          @host.save!
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -60,7 +60,7 @@ module Katello
           collection = custom_collection_by_content_view_version(@versions)
         else
           repos = Katello::Repository.where(:content_view_version_id => @versions.pluck(:id))
-          repos = repos.where(:library_instance_id => @repo.id) if @repo
+          repos = repos.where(:root_id => @repo.root_id) if @repo
           collection = filter_by_repos(repos, resource_class.all)
         end
 

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

@@ -7,7 +7,8 @@ module Katello
 
       module Overrides
         def edit
-          @can_toggle_sca = Katello::UpstreamConnectionChecker.new(@taxonomy).can_connect?
+          @can_toggle_sca = Katello::UpstreamConnectionChecker.new(@taxonomy).can_connect? &&
+            (@taxonomy.upstream_consumer.simple_content_access_eligible? || @taxonomy.simple_content_access?)
           super
         end
 

data/app/helpers/katello/katello_urls_helper.rb

@@ -6,12 +6,15 @@ module Katello
       ::Setting[:foreman_url].sub(%r|^.*?:|, "#{schema}:")
     end
 
-    def subscription_manager_configuration_url(host = nil, rpm = true)
-      prefix = if host&.content_source
+    def subscription_manager_configuration_url(host = nil, rpm = true, hostname: nil)
+      prefix = if hostname
+                 "http://#{hostname}"
+               elsif host&.content_source
                  "http://#{host.content_source.hostname}"
                else
                  foreman_settings_url
                end
+
       config = rpm ? SETTINGS[:katello][:consumer_cert_rpm] : SETTINGS[:katello][:consumer_cert_sh]
 
       "#{prefix}/pub/#{config}"

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

@@ -9,6 +9,7 @@ module Actions
           param :label
           param :content_url
           param :owner
+          param :os_versions
         end
 
         def run
@@ -19,6 +20,7 @@ module Actions
                      type: input[:type],
                      arches: input[:arches],
                      label: input[:label],
+                     requiredTags: input[:os_versions],
                      metadataExpire: 1,
                      vendor: ::Katello::Provider::CUSTOM)
         end

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

@@ -7,6 +7,7 @@ module Actions
           param :name
           param :type
           param :arches
+          param :os_versions
           param :label
           param :content_url
           param :gpg_key_url
@@ -22,6 +23,7 @@ module Actions
                      gpgUrl: input[:gpg_key_url] || '', #candlepin ignores nil
                      type: input[:type],
                      arches: input[:arches],
+                     requiredTags: input[:os_versions],
                      label: input[:label],
                      metadataExpire: 1,
                      vendor: ::Katello::Provider::CUSTOM)

data/app/lib/actions/katello/applicability/hosts/bulk_generate.rb

@@ -9,12 +9,8 @@ module Actions
 
           def run
             input[:host_ids].each do |host_id|
-              content_facet = ::Katello::Host::ContentFacet.find_by_host_id(host_id)
-              if content_facet.present?
-                content_facet.calculate_and_import_applicability
-              else
-                Rails.logger.warn(_("Content Facet for host with id %s is non-existent. Skipping applicability calculation.") % host_id)
-              end
+              content_facet = ::Host.find(host_id).content_facet
+              content_facet.calculate_and_import_applicability
             end
           end
 

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

@@ -20,14 +20,10 @@ module Actions
                                     Actions::Pulp3::CapsuleContent::Sync],
                                      repo, smart_proxy,
                                      skip_metadata_check: skip_metadata_check)
-                end
-              end
 
-              concurrence do
-                repo_batch.each do |repo|
                   if repo.is_a?(::Katello::Repository) &&
-                      repo.distribution_bootable? &&
-                      repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+                    repo.distribution_bootable? &&
+                    repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
                     plan_action(Katello::Repository::FetchPxeFiles,
                                 id: repo.id,
                                 capsule_id: smart_proxy.id)

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

@@ -9,7 +9,6 @@ module Actions
         def plan(content_view, description = "", options = {})
           action_subject(content_view)
           import_only = options.fetch(:import_only, false)
-          path = options[:path]
           content_view.check_ready_to_publish! unless import_only
 
           if options[:repos_units].present?
@@ -54,7 +53,7 @@ module Actions
             if separated_repo_map[:pulp3_yum].keys.flatten.present? &&
                 SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
               if import_only
-                handle_import(version, path)
+                handle_import(version, options.slice(:path, :metadata))
               else
                 plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
               end
@@ -188,8 +187,8 @@ module Actions
           end
         end
 
-        def handle_import(version, path)
-          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path)
+        def handle_import(version, path:, metadata:)
+          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)
           plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
           concurrence do
             version.importable_repositories.pluck(:id).each do |id|

data/app/lib/actions/katello/content_view_version/import.rb

@@ -4,13 +4,13 @@ module Actions
       class Import < Actions::EntryAction
         PULP_USER = 'pulp'.freeze
 
-        def plan(content_view, path:)
+        def plan(content_view, path:, metadata:)
           content_view.check_ready_to_import!
           unless SmartProxy.pulp_primary.pulp3_repository_type_support?(::Katello::Repository::YUM_TYPE)
-            fail HttpErrors::BadRequest, _("This API endpoint is only valid for Pulp 3 repositories.")
+            fail ::Katello::HttpErrors::BadRequest, _("This API endpoint is only valid for Pulp 3 repositories.")
           end
           ::Katello::Pulp3::ContentViewVersion::Import.check_permissions!(path)
-          metadata = ::Katello::Pulp3::ContentViewVersion::Import.metadata(path)
+
           major = metadata[:content_view_version][:major]
           minor = metadata[:content_view_version][:minor]
 
@@ -22,6 +22,7 @@ module Actions
 
           plan_action(::Actions::Katello::ContentView::Publish, content_view, '',
                         path: path,
+                        metadata: metadata,
                         import_only: true,
                         major: major,
                         minor: minor)

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -91,7 +91,8 @@ module Actions
               sequence do
                 new_puppet_environment = plan_action(Katello::ContentViewPuppetEnvironment::Clone, old_version,
                                                    :new_version => new_content_view_version).new_puppet_environment
-                copy_action_outputs += copy_puppet_content(new_puppet_environment, content[:puppet_module_ids]) unless content[:puppet_module_ids].blank?
+                check_puppet_module_duplicates(content[:puppet_module_ids])
+                copy_action_outputs += copy_puppet_content(new_puppet_environment, content[:puppet_module_ids], old_version) unless content[:puppet_module_ids].blank?
               end
             end
 
@@ -368,14 +369,28 @@ module Actions
           copy_outputs
         end
 
+        def check_puppet_module_duplicates(puppet_module_ids)
+          puppet_module_dup_counts = ::Katello::PuppetModule.where(id: puppet_module_ids).
+            select(:name, :author).group(:name, :author).having("count(*) > 1").size
+          if puppet_module_dup_counts.present?
+            offending_puppet_modules = puppet_module_dup_counts.keys.collect do |dup|
+              "#{dup[0]}-#{dup[1]}"
+            end
+            fail _("Adding multiple versions of the same Puppet Module is not supported by incremental update.  The following Puppet Modules have duplicate versions in the incremental update content list: %{dup_list}" % {:dup_list => offending_puppet_modules})
+          end
+        end
+
         def remove_puppet_modules(repo, puppet_module_ids)
           plan_action(Pulp::Repository::RemoveUnits, :content_view_puppet_environment_id => repo.id, :contents => puppet_module_ids, :content_unit_type => ::Katello::PuppetModule::CONTENT_TYPE)
         end
 
-        def copy_puppet_content(new_repo, puppet_module_ids)
+        def copy_puppet_content(new_repo, puppet_module_ids, old_version)
           copy_outputs = []
+          # Remove older versions
+          query = 'SELECT a.* FROM katello_puppet_modules a LEFT JOIN katello_puppet_modules b ON a.name = b.name AND a.author = b.author AND a.sortable_version < b.sortable_version WHERE b.sortable_version IS NOT NULL AND a.id IN (:old_version_puppet_module_ids)'
+          old_puppet_module_ids = ::Katello::PuppetModule.find_by_sql([query, :old_version_puppet_module_ids => old_version.puppet_modules.map(&:id)]).map(&:id)
           unless puppet_module_ids.blank?
-            remove_puppet_modules(new_repo, puppet_module_ids)
+            remove_puppet_modules(new_repo, (old_puppet_module_ids + puppet_module_ids).uniq)
             copy_outputs = puppet_module_ids.map { |module_id| copy_puppet_module(new_repo, module_id).output }
             plan_action(Pulp::ContentViewPuppetEnvironment::IndexContent, id: new_repo.id)
           end

data/app/lib/actions/katello/host/update_system_purpose.rb

@@ -0,0 +1,31 @@
+module Actions
+  module Katello
+    module Host
+      class UpdateSystemPurpose < Actions::EntryAction
+        def plan(host, service_level, purpose_role, purpose_usage, purpose_addons)
+          fail _("Host %s has not been registered with subscription-manager.") % host.name unless host.subscription_facet
+
+          host.subscription_facet.service_level = service_level unless service_level.nil?
+          host.subscription_facet.purpose_role = purpose_role unless purpose_role.nil?
+          host.subscription_facet.purpose_usage = purpose_usage unless purpose_usage.nil?
+
+          if purpose_addons
+            purpose_addon_objects = purpose_addons.delete_if(&:blank?).uniq.map { |x| ::Katello::PurposeAddon.find_or_create_by(name: x) }
+            host.subscription_facet.purpose_addons = purpose_addon_objects
+          end
+
+          host.subscription_facet.save!
+          plan_self(:hostname => host.name)
+        end
+
+        def humanized_name
+          if input&.dig(:hostname)
+            _("Updating System Purpose for host %s") % input[:hostname]
+          else
+            _("Updating System Purpose for host")
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/organization/manifest_delete.rb

@@ -40,7 +40,6 @@ module Actions
         end
 
         def finalize
-          subject_organization.clear_syspurpose_status if subject_organization.simple_content_access?(cached: false)
           subject_organization.audit_manifest_action(_('Manifest deleted'))
         end
       end

data/app/lib/actions/katello/organization/manifest_import.rb

@@ -45,7 +45,6 @@ module Actions
         end
 
         def finalize
-          subject_organization.clear_syspurpose_status if subject_organization.simple_content_access?(cached: false)
           subject_organization.clear_manifest_expired_notifications
           subject_organization.audit_manifest_action(_('Manifest imported'))
         end

data/app/lib/actions/katello/organization/manifest_refresh.rb

@@ -61,7 +61,6 @@ module Actions
 
         def finalize
           org = ::Organization.find(input[:organization_id])
-          subject_organization.clear_syspurpose_status if subject_organization.simple_content_access?(cached: false)
           org.clear_manifest_expired_notifications
           subject_organization.audit_manifest_action(_('Manifest refreshed'))
         end

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

@@ -8,12 +8,13 @@ module Actions
           sequence do
             if root.content_id.nil?
               content_create = plan_action(Candlepin::Product::ContentCreate,
-                                           owner:       root.product.organization.label,
-                                           name:        root.name,
-                                           type:        root.content_type,
-                                           arches:      root.format_arches,
-                                           label:       root.custom_content_label,
-                                           content_url: root.custom_content_path)
+                                           owner:         root.product.organization.label,
+                                           name:          root.name,
+                                           type:          root.content_type,
+                                           arches:        root.format_arches,
+                                           label:         root.custom_content_label,
+                                           os_versions:   root.os_versions&.join(','),
+                                           content_url:   root.custom_content_path)
               content_id = content_create.output[:response][:id]
               plan_action(Candlepin::Product::ContentAdd, owner: root.product.organization.label,
                                     product_id: root.product.cp_id,

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

@@ -10,6 +10,7 @@ module Actions
           param :upload_actions
         end
 
+        # rubocop:disable Metrics/MethodLength
         def run
           repo = ::Katello::Repository.find(input[:id])
           if repo.puppet?
@@ -21,7 +22,15 @@ module Actions
           elsif repo.file?
             ::Katello::FileUnit.import_for_repository(repo)
           elsif repo.deb?
-            unit_ids = search_units(repo)
+            if input[:import_upload_task] && input[:import_upload_task][:content_unit_href]
+              unit_ids = [input[:import_upload_task][:content_unit_href]]
+            elsif input[:upload_actions]&.any? { |action| action.try(:[], "content_unit_href") }
+              uploaded_content_unit_hrefs = []
+              input[:upload_actions].each { |action| uploaded_content_unit_hrefs << action.try(:[], "content_unit_href") }
+              unit_ids = uploaded_content_unit_hrefs.compact
+            else
+              unit_ids = search_units(repo)
+            end
             ::Katello::Deb.import_all(unit_ids, repo)
           elsif repo.yum?
             if input[:import_upload_task] && input[:import_upload_task][:content_unit_href]