katello 4.1.0 → 4.2.0.rc1

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

@@ -2,7 +2,6 @@ module Katello
   class Api::V2::UpstreamSubscriptionsController < Api::V2::ApiController
     before_action :find_organization
     before_action :check_upstream_connection
-    before_action :deprecated, only: [:simple_content_access_eligible, :enable_simple_content_access, :disable_simple_content_access]
     resource_description do
       description "Red Hat subscriptions management platform."
       api_version 'v2'
@@ -77,29 +76,6 @@ module Katello
       render json: { status: 'OK' }
     end
 
-    api :GET, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/eligible",
-      N_("Check if the specified organization is eligible for Simple Content Access"), :deprecated => true
-    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"), :deprecated => true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
-    def enable_simple_content_access
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/disable",
-      N_("Disable simple content access for a manifest"), :deprecated => true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
-    def disable_simple_content_access
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
-      respond_for_async :resource => task
-    end
-
     private
 
     def update_params
@@ -124,9 +100,5 @@ module Katello
         { "pool" => pool[:id], "quantity" => pool[:quantity] } if pool
       end
     end
-
-    def deprecated
-      ::Foreman::Deprecation.api_deprecation_warning("This will be removed in Katello 4.2, Please see /api/v2/simple_content_access")
-    end
   end
 end

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

@@ -17,9 +17,8 @@ module Katello
           args
         end
 
-        def append_array_of_ids(hash_params)
-          return if registration_params['activation_key'].present? || registration_params['activation_keys'].present?
-          super
+        def append_array_of_ids(*)
+          return
         end
       end
 
@@ -28,8 +27,8 @@ module Katello
 
         update_api(:create) do
           param :registration_command, Hash do
-            param :activation_key, String, desc: N_('Activation key for subscription-manager client. Required for CentOS and Red Hat Enterprise Linux. Multiple keys add separated by comma, example: key1,key2,key3.'), deprecated: true
-            param :activation_keys, Array, required: true, desc: N_('Activation key(s) for subscription-manager client. Required for CentOS and Red Hat Enterprise Linux. Required only if host group has no activation keys')
+            param :activation_key, String, desc: N_('Activation key for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. For multiple keys use `activation_keys` param instead.'), deprecated: true
+            param :activation_keys, Array, desc: N_('Activation keys for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. Required only if host group has no activation keys.')
             param :lifecycle_environment_id, :number, required: false, desc: N_('Lifecycle environment for the host.')
             param :force, :bool, required: false, desc: N_('Clear any previous registration and run subscription-manager with --force.')
             param :ignore_subman_errors, :bool, required: false, desc: N_('Ignore subscription-manager errors for `subscription-manager register` command')
@@ -40,6 +39,28 @@ module Katello
       included do
         prepend Overrides
         include ApiPieExtensions
+
+        before_action :check_activation_keys, only: [:create]
+      end
+
+      private
+
+      def check_activation_keys
+        return if params['registration_command']['activation_key'].present? ||
+                  params['registration_command']['activation_keys'].present? ||
+                  hostgroup_have_acks?
+
+        render_error 'custom_error', status: :unprocessable_entity,
+                                     locals: { message: N_('Missing activation key!') }
+      end
+
+      def hostgroup_have_acks?
+        return unless params['registration_command']['hostgroup_id']
+
+        ::Hostgroup.authorized(:view_hostgroups)
+                   .find(params['registration_command']['hostgroup_id'])
+                   .params['kt_activation_keys']
+                   .present?
       end
     end
   end

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

@@ -7,7 +7,7 @@ module Katello
         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']
+            msg = _("Host was not found by the subscription UUID: '%s', this can happen if the host is registered already, but not to this instance") % params['uuid']
             fail ActiveRecord::RecordNotFound, msg
           end
           @host.assign_attributes(host_params('host'))
@@ -19,11 +19,38 @@ module Katello
 
       def host_setup_extension
         if params['host']['lifecycle_environment_id']
-          @host.update!(lifecycle_environment: KTEnvironment.readable.find(params['host']['lifecycle_environment_id']))
+          new_lce = KTEnvironment.readable.find(params['host']['lifecycle_environment_id'])
+          @host.content_facet.lifecycle_environment = new_lce
+          @host.update_candlepin_associations
         end
 
         super
       end
+
+      def context_urls
+        super.merge(rhsm_url: rhsm_url, pulp_content_url: pulp_content_url)
+      end
+
+      private
+
+      def smart_proxy
+        @smart_proxy ||= begin
+          proxy = params[:url] ? SmartProxy.find_by(url: params[:url]) : SmartProxy.pulp_primary
+
+          fail Foreman::Exception, _('Smart proxy content source not found!') unless proxy
+          fail Foreman::Exception, _('Pulp 3 is not enabled on Smart proxy!') unless proxy.pulp3_enabled?
+
+          proxy
+        end
+      end
+
+      def rhsm_url
+        URI(smart_proxy.rhsm_url)
+      end
+
+      def pulp_content_url
+        smart_proxy.setting(SmartProxy::PULP3_FEATURE, 'content_app_url')
+      end
     end
   end
 end

data/app/lib/actions/candlepin/environment/destroy.rb

@@ -8,6 +8,8 @@ module Actions
 
         def run
           ::Katello::Resources::Candlepin::Environment.destroy(input['cp_id'])
+        rescue ::Katello::Errors::CandlepinEnvironmentGone
+          Rails.logger.info("Candlepin environment cp_id=#{input['cp_id']} was not found, continuing")
         end
       end
     end

data/app/lib/actions/katello/agent_action.rb

@@ -47,14 +47,14 @@ module Actions
 
             dispatch_message(history) unless input[:bulk]
 
-            schedule_timeout(timeout)
+            schedule_timeout(timeout, optional: true)
           end
         when Dynflow::Action::Skip
           # Do not fail and goto a paused state, instead skip and send the state to warning so we do not block other host actions
         when Dynflow::Action::Timeouts::Timeout
           process_timeout
         when 'accepted'
-          schedule_timeout(finish_timeout)
+          schedule_timeout(finish_timeout, optional: true)
           suspend
         else
           fail_on_errors

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

@@ -15,8 +15,9 @@ module Actions
             repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
                 repo_batch.each do |repo|
-                  plan_pulp_action([Actions::Pulp::Orchestration::Repository::SmartProxySync,
-                                    Actions::Pulp3::CapsuleContent::Sync],
+                  plan_pulp_action(
+                    [Actions::Pulp::Orchestration::Repository::SmartProxySync,
+                     Actions::Pulp3::CapsuleContent::Sync],
                                      repo, smart_proxy,
                                      skip_metadata_check: skip_metadata_check)
                 end

data/app/lib/actions/katello/{gpg_key → content_credential}/update.rb

@@ -1,6 +1,6 @@
 module Actions
   module Katello
-    module GpgKey
+    module ContentCredential
       class Update < Actions::EntryAction
         def plan(gpg_key, gpg_key_params)
           action_subject gpg_key

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

@@ -77,7 +77,7 @@ module Actions
             plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library)) unless options[:skip_promotion]
             plan_action(Katello::Foreman::ContentUpdate, library, content_view) unless options[:skip_promotion]
             plan_action(ContentView::ErrataMail, content_view, library) unless options[:skip_promotion]
-
+            plan_action(ContentView::Promote, version, find_environments(options[:environment_ids]), options[:is_force_promote]) if options[:environment_ids]&.any?
             plan_self(history_id: history.id, content_view_id: content_view.id,
                       auto_publish_composite_ids: auto_publish_composite_ids(content_view),
                       content_view_version_name: version.name,
@@ -186,6 +186,11 @@ module Actions
           end
         end
 
+        def find_environments(environment_ids)
+          return nil unless environment_ids&.any?
+          ::Katello::KTEnvironment.where(:id => environment_ids)
+        end
+
         def handle_import(version, path:, metadata:)
           sequence do
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)

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

@@ -10,7 +10,7 @@ module Actions
             source_repositories.each do |repositories|
               new_repository = repositories.first.build_clone(content_view: version.content_view,
                                                              version: version)
-              plan_action(Repository::Create, new_repository, true, false)
+              plan_action(Repository::Create, new_repository, true)
               repository_mapping[repositories] = new_repository
             end
           end

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

@@ -1,7 +1,6 @@
 module Actions
   module Katello
     module ContentViewVersion
-      # rubocop:disable Metrics/ClassLength
       class IncrementalUpdate < Actions::EntryAction
         include ::Katello::ContentViewHelper
         attr_accessor :new_content_view_version
@@ -18,6 +17,7 @@ module Actions
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
         def plan(old_version, environments, options = {})
           dep_solve = options.fetch(:resolve_dependencies, true)
           description = options.fetch(:description, '')
@@ -71,18 +71,22 @@ module Actions
                 unit_map = pulp3_content_mapping(content)
 
                 unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
-                  copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
-                                                     dependency_solving: dep_solve).output
+                  sequence do
+                    copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
+                                                       dependency_solving: dep_solve).output
+                    repos_to_clone.each do |source_repos|
+                      if separated_repo_map[:pulp3_yum].keys.include?(source_repos)
+                        copy_repos(repository_mapping[source_repos])
+                      end
+                    end
+                  end
                 end
               end
 
               if separated_repo_map[:other].keys.flatten.present?
                 repos_to_clone.each do |source_repos|
                   if separated_repo_map[:other].keys.include?(source_repos)
-                    copy_action_outputs += copy_repos(repository_mapping[source_repos],
-                                                      new_content_view_version,
-                                                      content,
-                                                      dep_solve)
+                    copy_repos(repository_mapping[source_repos])
                   end
                 end
               end
@@ -138,19 +142,11 @@ module Actions
           end
         end
 
-        def copy_repos(new_repo, new_version, content, dep_solve)
-          copy_output = []
+        def copy_repos(new_repo)
           sequence do
-            solve_dependencies = new_version.content_view.solve_dependencies || dep_solve
-            copy_output += copy_deb_content(new_repo, solve_dependencies, content[:deb_ids])
-            copy_output += copy_yum_content(new_repo, solve_dependencies,
-                                            content[:package_ids],
-                                            content[:errata_ids])
-
             plan_action(Katello::Repository::MetadataGenerate, new_repo)
             plan_action(Katello::Repository::IndexContent, id: new_repo.id)
           end
-          copy_output
         end
 
         # For a given repo, find it's instances in both the new and old component versions.
@@ -328,52 +324,6 @@ module Actions
           plan_action(Katello::ContentView::Promote, new_version, environments, true, nil, true)
         end
 
-        def copy_deb_content(new_repo, dep_solve, deb_ids)
-          copy_outputs = []
-          if new_repo.content_type == ::Katello::Repository::DEB_TYPE
-            unless deb_ids.blank?
-              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
-                                          ::Katello::Deb.with_identifiers(deb_ids),
-                                          incremental_update: dep_solve).output
-            end
-          end
-          copy_outputs
-        end
-
-        def copy_yum_content(new_repo, dep_solve, package_ids, errata_ids)
-          return [] unless new_repo.content_type == ::Katello::Repository::YUM_TYPE
-
-          copy_outputs = []
-
-          unless errata_ids.blank?
-            content_present_in_this_repo = new_repo
-                                            .library_instance
-                                            .errata
-                                            .with_identifiers(errata_ids)
-                                            .exists?
-            if content_present_in_this_repo
-              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
-                                          ::Katello::Erratum.with_identifiers(errata_ids),
-                                          incremental_update: dep_solve).output
-            end
-          end
-
-          unless package_ids.blank?
-            content_present_in_this_repo = new_repo
-                                            .library_instance
-                                            .rpms
-                                            .with_identifiers(package_ids)
-                                            .exists?
-            if content_present_in_this_repo
-              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
-                                          ::Katello::Rpm.with_identifiers(package_ids),
-                                          incremental_update: dep_solve).output
-            end
-          end
-
-          copy_outputs
-        end
-
         def plan_copy(action_class, source_repo, target_repo, clauses = nil, override_config = nil)
           plan_action(action_class,
                       :source_pulp_id => source_repo.pulp_id,

data/app/lib/actions/katello/orphan_cleanup/remove_orphans.rb

@@ -19,7 +19,7 @@ module Actions
 
         def run
           models = []
-          ::Katello::RepositoryTypeManager.repository_types.each_value do |repo_type|
+          ::Katello::RepositoryTypeManager.enabled_repository_types.each_value do |repo_type|
             indexable_types = repo_type.content_types_to_index
             models += indexable_types&.map(&:model_class)
             models.select! { |model| model.many_repository_associations }

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

@@ -2,20 +2,18 @@ module Actions
   module Katello
     module Repository
       class CloneContents < Actions::Base
-        include Actions::Katello::PulpSelector
         include Actions::Katello::CheckMatchingContent
 
         def plan(source_repositories, new_repository, options)
           filters = options.fetch(:filters, nil)
           rpm_filenames = options.fetch(:rpm_filenames, nil)
           generate_metadata = options.fetch(:generate_metadata, true)
-          purge_empty_contents = options.fetch(:purge_empty_contents, false)
           copy_contents = options.fetch(:copy_contents, true)
           solve_dependencies = options.fetch(:solve_dependencies, false)
 
           sequence do
             if copy_contents
-              plan_pulp_action([Pulp3::Orchestration::Repository::CopyAllUnits, Pulp::Orchestration::Repository::CopyAllUnits],
+              plan_action(Pulp3::Orchestration::Repository::CopyAllUnits,
                           new_repository,
                           SmartProxy.pulp_primary,
                           source_repositories,
@@ -29,10 +27,6 @@ module Actions
             index_options[:source_repository_id] = source_repositories.first.id if source_repositories.count == 1 && filters.empty? && rpm_filenames.nil?
             index_options[:matching_content] = matching_content
             plan_action(Katello::Repository::IndexContent, index_options)
-
-            if purge_empty_contents && new_repository.backend_service(SmartProxy.pulp_primary).should_purge_empty_contents?
-              plan_action(Katello::Repository::PurgeEmptyContent, id: new_repository.id)
-            end
           end
         end
 

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

@@ -4,18 +4,12 @@ module Actions
       # Clones the contnet of the repository into the environment
       # effectively promotion the repository to the environment
       class CloneToEnvironment < Actions::Base
-        include Actions::Katello::PulpSelector
         def plan(repository, environment)
           clone = find_or_build_environment_clone(repository, environment)
 
           sequence do
             if clone.new_record?
-              plan_action(Repository::Create, clone, true, false)
-            else
-              #only clear if it should be empty, but its not
-              plan_optional_pulp_action([Actions::Pulp::Repository::Clear], clone, SmartProxy.pulp_primary)
-              # Do we need to refresh distributors here?
-              plan_optional_pulp_action([Actions::Pulp::Orchestration::Repository::RefreshIfNeeded], clone, SmartProxy.pulp_primary)
+              plan_action(Repository::Create, clone, true)
             end
 
             plan_action(::Actions::Katello::Repository::CloneContents, [repository], clone, :copy_contents => !clone.yum?)

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

@@ -2,18 +2,15 @@ module Actions
   module Katello
     module Repository
       class Create < Actions::EntryAction
-        include Actions::Katello::PulpSelector
-
-        def plan(repository, clone = false, plan_create = false)
+        def plan(repository, clone = false)
           repository.save!
           root = repository.root
 
           action_subject(repository)
 
           org = repository.organization
-          pulp2_create_action = plan_create ? Actions::Pulp::Repository::CreateInPlan : Actions::Pulp::Repository::Create
           sequence do
-            create_action = plan_pulp_action([pulp2_create_action, Pulp3::Orchestration::Repository::Create],
+            create_action = plan_action(Pulp3::Orchestration::Repository::Create,
                                         repository, SmartProxy.pulp_primary)
 
             return if create_action.error

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

@@ -10,7 +10,7 @@ module Actions
           repository.relative_path = repository.custom_repo_path
           repository.save!
           action_subject(repository)
-          plan_action(::Actions::Katello::Repository::Create, repository, false, true)
+          plan_action(::Actions::Katello::Repository::Create, repository, false)
         end
 
         def humanized_name

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

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module Repository
       class Destroy < Actions::EntryAction
-        include Actions::Katello::PulpSelector
         middleware.use ::Actions::Middleware::RemoteAction
 
         # options:
@@ -20,8 +19,7 @@ module Actions
             fail repository.errors.messages.values.join("\n")
           end
 
-          plan_pulp_action([Actions::Pulp::Orchestration::Repository::Delete,
-                            Actions::Pulp3::Orchestration::Repository::Delete],
+          plan_action(Actions::Pulp3::Orchestration::Repository::Delete,
                            repository,
                            SmartProxy.pulp_primary)