katello 4.1.0.rc1.1 → 4.1.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fa898f182416d7da9cfa56ef84ea10f11e4a18981202e4ba0ad65367408a4ca
-  data.tar.gz: e917344f18c0c835e31acc4463bfff10808a41e66fad2c3f9d833c55c234abae
+  metadata.gz: 99a0b0413b05278dfda949b6b01e9a2d8bac8c244f655cce8dfb9988dd313c11
+  data.tar.gz: e89dd3e7972f12b5c9f49938fd3a1a7ad84c43db85a28633cd88e9ae10871479
 SHA512:
-  metadata.gz: 98470123a70cff266bec4e69e281bba4b492192ff815d57f92f1a1decadbbff15aeabbe5b02abd97c7a60a2fc20f9b853addfec46075dcdbdd1dd3893ae03380
-  data.tar.gz: c9a0bc998ef5413fb348f983b132d385dbdd9d1039098dbee25adc71456b34fd9ec31b45e26c93ade8f9b02672bc0be75a6d08772ccb6da1716a6b6da02d2833
+  metadata.gz: 4d8f557a3027d6fa57addc08cf3cd690610e1d8a6635bbcb9aff7335f56975ec22232de2b774ee9bb4cc946a81596411d1081bb40e17f9b7f950b11b4f52dfb9
+  data.tar.gz: 3d706c5f2647a275b4d38886d4edeb81870ac1f72ff8cfddf4ab15c568990ea0a71bbb69d675e0bb2bcbbe9a339627340e52fb5d478024c8185e740193e82740

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

@@ -8,8 +8,8 @@ module Katello
     api :POST, "/content_export_incrementals/version", N_("Performs an incremental-export of a content view version.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
     param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_mb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in megabytes."), :required => false
+    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
+                                               "no greater than the specified size in gigabytes."), :required => false
     param :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
                                                  "If not provided the most recent export history will be used."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
@@ -18,7 +18,7 @@ module Katello
       tasks = async_task(Actions::Katello::ContentViewVersion::Export,
                           content_view_version: @version,
                           destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_mb],
+                          chunk_size: params[:chunk_size_gb],
                           from_history: @history,
                           fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
 
@@ -28,8 +28,8 @@ module Katello
     api :POST, "/content_export_incrementals/library", N_("Performs an incremental-export of the repositories in library.")
     param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
     param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_mb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in megabytes."), :required => false
+    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
+                                               "no greater than the specified size in gigabytes."), :required => false
     param :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
                                                  "If not provided the most recent export history will be used."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
@@ -38,7 +38,7 @@ module Katello
       tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
                           @organization,
                           destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_mb],
+                          chunk_size: params[:chunk_size_gb],
                           from_history: @history,
                           fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
       respond_for_async :resource => tasks

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

@@ -29,15 +29,15 @@ module Katello
     api :POST, "/content_exports/version", N_("Performs a full-export of a content view version.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
     param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_mb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in megabytes."), :required => false
+    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
+                                               "no greater than the specified size in gigabytes."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
                                                          " are unexportable. False by default."), :required => false
     def version
       tasks = async_task(::Actions::Katello::ContentViewVersion::Export,
                           content_view_version: @version,
                           destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_mb],
+                          chunk_size: params[:chunk_size_gb],
                           fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
       respond_for_async :resource => tasks
     end
@@ -45,15 +45,15 @@ module Katello
     api :POST, "/content_exports/library", N_("Performs a full-export of the repositories in library.")
     param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
     param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_mb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in megabytes."), :required => false
+    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
+                                               "no greater than the specified size in gigabytes."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
                                                          " are unexportable. False by default."), :required => false
     def library
       tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
                           @organization,
                           destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_mb],
+                          chunk_size: params[:chunk_size_gb],
                           fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
       respond_for_async :resource => tasks
     end

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

@@ -13,7 +13,7 @@ module Katello
                             .where(organization_id: registration_params[:organization_id])
                             .order(:name)
 
-        data = { activationKeys: aks, lifeCycleEnvironments: lces }
+        data = { activationKeys: aks, lifecycleEnvironments: lces }
 
         if registration_params[:hostgroup_id].present?
           host_group = ::Hostgroup.authorized(:view_hostgroups).find(registration_params[:hostgroup_id])

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

@@ -135,6 +135,14 @@ module Actions
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
+        def content_view_version_id
+          input['content_view_version_id']
+        end
+
+        def content_view_version_name
+          input['content_view_version_name']
+        end
+
         private
 
         def include_other_components(override_components, content_view)
@@ -190,14 +198,6 @@ module Actions
           end
         end
 
-        def content_view_version_id
-          input['content_view_version_id']
-        end
-
-        def content_view_version_name
-          input['content_view_version_name']
-        end
-
         apipie :class, "A class representing #{self} object" do
           desc 'This object is available as **@object** variable in
                 webhook templates when a corresponding event occures.

data/app/lib/actions/pulp3/orchestration/content_view_version/export.rb

@@ -30,7 +30,8 @@ module Actions
                   destination_server: destination_server,
                   from_content_view_version: from_content_view_version)
               export_service.validate!(fail_on_missing_content: fail_on_missing_content,
-                                       validate_incremental: validate_incremental)
+                                       validate_incremental: validate_incremental,
+                                       chunk_size: chunk_size)
 
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
                                           content_view_version_id: content_view_version.id,

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -209,9 +209,11 @@ module Katello
         search = [search_up_to, search_since, search_result].compact.join(' and ')
 
         if Katello.with_remote_execution?
-          condition = ["state != 'stopped' AND (label = 'Actions::RemoteExecution::RunHostJob' AND templates.id = ?) OR label = 'Actions::Katello::Host::Erratum::Install'", RemoteExecutionFeature.feature('katello_errata_install').job_template_id]
+          condition = ["state = 'stopped' AND ((label = 'Actions::RemoteExecution::RunHostJob' AND templates.id = ?) " \
+                       "OR label = 'Actions::Katello::Host::Erratum::Install' OR label = 'Actions::Katello::Host::Erratum::ApplicableErrataInstall')",
+                       RemoteExecutionFeature.feature('katello_errata_install').job_template_id]
         else
-          condition = "state != 'stopped' AND label = 'Actions::Katello::Host::Erratum::Install'"
+          condition = "state = 'stopped' AND (label = 'Actions::Katello::Host::Erratum::Install' OR label = 'Actions::Katello::Host::Erratum::ApplicableErrataInstall')"
         end
 
         tasks = load_resource(klass: ForemanTasks::Task,
@@ -219,19 +221,20 @@ module Katello
                               permission: 'view_foreman_tasks',
                               joins: 'LEFT OUTER JOIN template_invocations ON foreman_tasks_tasks.id = template_invocations.run_host_job_task_id LEFT OUTER JOIN templates ON template_invocations.template_id = templates.id',
                               select: 'foreman_tasks_tasks.*,template_invocations.id AS template_invocation_id',
-                              search: search
-        )
+                              search: search)
         only_host_ids = ::Host.search_for(host_filter).pluck(:id) if host_filter
 
         # batch of 1_000 records
         tasks.each do |batch|
+          @_tasks_input = {}
           @_tasks_errata_cache = {}
           seen_errata_ids = []
           seen_host_ids = []
 
           batch.each do |task|
+            next if skip_task?(task)
             seen_errata_ids = (seen_errata_ids + parse_errata(task)).uniq
-            seen_host_ids << task.input['host']['id'].to_i if include_last_reboot == 'yes'
+            seen_host_ids << get_task_input(task)['host']['id'].to_i if include_last_reboot == 'yes'
           end
           seen_host_ids &= only_host_ids if only_host_ids
 
@@ -240,6 +243,7 @@ module Katello
           preloaded_hosts = ::Host.where(:id => seen_host_ids).includes(:reported_data)
 
           batch.each do |task|
+            next if skip_task?(task)
             next if !only_host_ids.nil? && only_host_ids.include?(task.input['host']['id'].to_i)
             parse_errata(task).each do |erratum_id|
               current_erratum_errata_type = preloaded_errata.find { |k, _| k == erratum_id }.last
@@ -250,14 +254,15 @@ module Katello
 
               hash = {
                 :date => task.ended_at,
-                :hostname => task.input['host']['name'],
+                :hostname => get_task_input(task)['host']['name'],
                 :erratum_id => erratum_id,
                 :erratum_type => current_erratum_errata_type,
                 :status => task.result
               }
 
               if include_last_reboot == 'yes'
-                hash[:last_reboot_time] = preloaded_hosts.find { |k, _| k.id == task.input['host']['id'] }.uptime_seconds&.seconds&.ago
+                # It is possible that we can't find the host if it has been deleted.
+                hash[:last_reboot_time] = preloaded_hosts.find { |k, _| k.id == get_task_input(task)['host']['id'].to_i }&.uptime_seconds&.seconds&.ago
               end
 
               result << hash
@@ -289,14 +294,29 @@ module Katello
         host.subscription_facet
       end
 
+      def skip_task?(task)
+        # Skip task that doesn't apply errata
+        input = get_task_input(task)
+        input.blank? || input['host'].blank?
+      end
+
+      def get_task_input(task)
+        @_tasks_input[task.id] ||= if task.label == 'Actions::Katello::Host::Erratum::ApplicableErrataInstall'
+                                     task.execution_plan_action.all_planned_actions(Actions::Katello::Host::Erratum::Install).first.try(:input) || {}
+                                   else
+                                     task.input
+                                   end
+      end
+
       def parse_errata(task)
-        @_tasks_errata_cache[task.id] ||= if task.input['errata'].present?
-                                            # katello agent errata
-                                            task.input['errata']
-                                          else
-                                            # rex errata
-                                            TemplateInvocationInputValue.where(:template_invocation_id => task.template_invocation_id).limit(1).pluck(:value).first.split(',')
-                                          end
+        task_input = get_task_input(task)
+        agent_input = task_input['errata'] || task_input['content']
+        # Pick katello agent errata if present
+        # Otherwise pick rex errata. There are multiple template inputs, such as errata, pre_script and post_script we only need the
+        # errata input here.
+        @_tasks_errata_cache[task.id] ||= agent_input.presence || TemplateInvocationInputValue.joins(:template_input)
+                                            .where("template_invocation_id = ? AND template_inputs.name = ?", task.template_invocation_id, 'errata')
+                                            .first.value.split(',')
       end
     end
   end

data/app/lib/katello/http_resource.rb

@@ -66,17 +66,7 @@ module Katello
 
       def print_debug_info(_a_path, headers = {}, payload = {})
         logger.debug "Headers: #{headers.to_json}"
-        # calling to_json on file has side-effects breaking manifest import.
-        # this fix prevents this problem
-        payload_to_print = payload.reduce({}) do |h, (k, v)|
-          h[k] = case v
-                 when File then "{{file}}"
-                 else v
-                 end
-        end
-        logger.debug "Body: #{filter_sensitive_data(payload_to_print.to_json)}"
-      rescue
-        logger.debug "Unable to print debug information"
+        logger.debug "Body: #{filter_sensitive_data(payload.to_json)}"
       end
 
       def get(a_path, headers = {})

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

@@ -121,7 +121,7 @@ module Katello
           facet_model = Facets.registered_facets[facet].hostgroup_configuration.model
           value = facet_model.where.not(attribute => nil).joins(:hostgroup).merge(
             ::Hostgroup.where(id: self.ancestor_ids).reorder(ancestry: :desc)
-          ).limit(1).pluck(attribute)
+          ).limit(1).pluck(attribute).first
         end
         value
       end

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

@@ -58,8 +58,7 @@ module Katello
       def update_repository_proxy_details
         changes = self.previous_changes
         if changes.key?(:url) || changes.key?(:username) || changes.key?(:password)
-
-          repos = repositories_with_proxy(id).uniq.collect(&:library_instance)
+          repos = ::Katello::Repository.where(root_id: repositories_with_proxy(id).pluck(:id)).where.not(remote_href: nil).where(library_instance_id: nil)
 
           unless repos.empty?
             ForemanTasks.async_task(

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

@@ -17,7 +17,7 @@ module Katello
 
       def update_global_proxies
         if saved_change_to_attribute?(:value) && name == 'content_default_http_proxy'
-          repos = RootRepository.with_global_proxy.collect(&:library_instance).uniq
+          repos = ::Katello::Repository.joins(:root).merge(Katello::RootRepository.with_global_proxy).where.not(remote_href: nil).where(library_instance_id: nil)
 
           unless repos.empty?
             ForemanTasks.async_task(

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

@@ -3,18 +3,35 @@ module Katello
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def get_candlepin_ids(organization)
-        self.get_for_owner(organization.label).map { |subscription| subscription["id"] }
+      def candlepin_records_by_id(organization)
+        records = get_for_owner(organization.label)
+        records_by_id = {}
+        records.each do |record|
+          records_by_id[record['id']] = record
+        end
+        records_by_id
       end
 
-      def import_candlepin_ids(organization)
-        candlepin_ids = self.get_candlepin_ids(organization)
-        candlepin_ids.each do |cp_id|
-          Katello::Util::Support.active_record_retry do
-            self.where(:cp_id => cp_id, :organization_id => organization.id).first_or_create unless cp_id.nil?
-          end
+      def import_candlepin_records(candlepin_objects, org)
+        candlepin_objects.each do |object|
+          import_candlepin_record(record: object, organization: org)
+        end
+      end
+
+      def import_candlepin_record(record:, organization:)
+        db_attrs = {
+          cp_id: record['id'],
+          organization: organization
+        }
+
+        yield(db_attrs) if block_given?
+
+        persisted = nil
+        Katello::Util::Support.active_record_retry do
+          persisted = self.where(db_attrs).first_or_create!
         end
-        candlepin_ids
+
+        persisted
       end
 
       def with_identifier(ids)
@@ -32,11 +49,12 @@ module Katello
         organizations = organization ? [organization] : Organization.all
 
         organizations.each do |org|
-          candlepin_ids = import_candlepin_ids(org)
+          candlepin_records = candlepin_records_by_id(org)
+          import_candlepin_records(candlepin_records.values, org)
 
           objects = self.in_organization(org)
           objects.each do |item|
-            exists_in_candlepin = candlepin_ids.include?(item.cp_id)
+            exists_in_candlepin = candlepin_records.key?(item.cp_id)
 
             Katello::Logging.time("Imported #{self}", data: { cp_id: item.cp_id, destroyed: !exists_in_candlepin }) do
               if exists_in_candlepin

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

@@ -50,17 +50,21 @@ module Katello
           org = Organization.find_by(label: json['owner']['key'])
           fail("Organization with label #{json['owner']['key']} wasn't found while importing Candlepin pool") unless org
 
-          subscription = determine_subscription(
-            product_id: json['productId'],
-            source_stack_id: json['sourceStackId'],
-            organization: org
-          )
-
-          ::Katello::Util::Support.active_record_retry do
-            pool = Katello::Pool.where(cp_id: cp_pool_id, organization: org, subscription: subscription).first_or_create!
-            pool.backend_data = json
-            pool.import_data(index_hosts)
-          end
+          pool = import_candlepin_record(record: json, organization: org)
+          pool.backend_data = json
+          pool.import_data(index_hosts)
+        end
+      end
+
+      def import_candlepin_record(record:, organization:)
+        subscription = determine_subscription(
+          product_id: record['productId'],
+          source_stack_id: record['sourceStackId'],
+          organization: organization
+        )
+
+        super do |attrs|
+          attrs[:subscription] = subscription
         end
       end
 

data/app/models/katello/pool.rb

@@ -24,8 +24,8 @@ module Katello
     scope :upstream, -> { where.not(upstream_pool_id: nil) }
     scope :redhat, -> { joins(:products).merge(Katello::Product.redhat).distinct }
 
-    include Glue::Candlepin::Pool
     include Glue::Candlepin::CandlepinObject
+    include Glue::Candlepin::Pool
 
     scoped_search :on => :cp_id, :complete_value => true, :rename => :id, :only_explicit => true
     scoped_search :on => :upstream_pool_id, :complete_value => true, :only_explicit => true

data/app/services/katello/pulp3/content_view_version/export.rb

@@ -53,7 +53,7 @@ module Katello
 
         def create_export(exporter_href, chunk_size: nil)
           options = { versions: version_hrefs }
-          options[:chunk_size] = "#{chunk_size}MB" if chunk_size
+          options[:chunk_size] = "#{chunk_size}GB" if chunk_size
           if from_content_view_version
             from_exporter = Export.new(smart_proxy: smart_proxy, content_view_version: from_content_view_version)
             start_versions = from_exporter.version_hrefs
@@ -91,9 +91,18 @@ module Katello
           api.exporter_api.delete(exporter_href)
         end
 
-        def validate!(fail_on_missing_content: true, validate_incremental: true)
+        def validate_chunk_size(size)
+          return if size.blank?
+
+          unless size.is_a?(Numeric) && size > 0 && size < 1e6
+            fail _("Specify an export chunk size less than 1_000_000 GB")
+          end
+        end
+
+        def validate!(fail_on_missing_content: true, validate_incremental: true, chunk_size: nil)
           validate_repositories_immediate! if fail_on_missing_content
           validate_incremental_export! if validate_incremental && !from_content_view_version.blank?
+          validate_chunk_size(chunk_size)
         end
 
         def validate_repositories_immediate!

data/app/services/katello/pulp3/repository.rb

@@ -136,7 +136,10 @@ module Katello
       def remote_needs_updates?
         if repo.remote_href
           remote = get_remote
-          computed = compute_remote_options
+          # The proxy auth creds are not returned by the Pulp API.
+          # The creds don't need to be checked here because they
+          # won't be updated outside of UpdateRemote.
+          computed = compute_remote_options.slice!(:proxy_username, :proxy_password)
           computed.keys.any? { |key| remote.send(key) != computed[key] }
         elsif repo.url
           true
@@ -348,7 +351,9 @@ module Katello
           tls_validation: root.verify_ssl_on_sync,
           name: generate_backend_object_name,
           url: root.url,
-          proxy_url: root.http_proxy&.full_url,
+          proxy_url: root.http_proxy&.url,
+          proxy_username: root.http_proxy&.username,
+          proxy_password: root.http_proxy&.password,
           total_timeout: Setting[:sync_connect_timeout]
         }
         remote_options[:url] = root.url unless root.url.blank?

data/app/services/katello/pulp3/repository/apt.rb

@@ -27,8 +27,7 @@ module Katello
           popts = super(repository_version)
           popts.merge!(
             {
-              # structured is not necessary for subscription-manager
-              #structured: true, # publish real suites (e.g. 'stable')
+              structured: true, # publish real suites (e.g. 'stable')
               simple: true # publish all into 'default'-suite
             }
           )

data/engines/bastion_katello/app/assets/javascripts/bastion_katello/activation-keys/details/activation-key-details-info.controller.js

@@ -25,10 +25,6 @@ angular.module('Bastion.activation-keys').controller('ActivationKeyDetailsInfoCo
 
         $scope.environments = Organization.readableEnvironments({id: CurrentOrganization});
 
-        $scope.$on('activationKey.loaded', function () {
-            $scope.originalEnvironment = $scope.activationKey.environment;
-        });
-
         $scope.$watch('activationKey.environment', function (environment) {
             if ($scope.originalEnvironment) {
                 if (environment) {
@@ -63,8 +59,7 @@ angular.module('Bastion.activation-keys').controller('ActivationKeyDetailsInfoCo
             $scope.editContentView = false;
             $scope.editEnvironment = false;
             $scope.save(activationKey).then(function (actKey) {
-                $scope.originalEnvironment = actKey.environment;
-                $scope.resetEnvironmentPathSelector(activationKey);
+                $scope.resetEnvironmentPathSelector(actKey);
             });
             $scope.disableEnvironmentSelection = false;
         };

data/engines/bastion_katello/app/assets/javascripts/bastion_katello/activation-keys/details/activation-key-details.controller.js

@@ -52,8 +52,8 @@ angular.module('Bastion.activation-keys').controller('ActivationKeyDetailsContro
         };
 
         $scope.activationKey = ActivationKey.get({id: $scope.$stateParams.activationKeyId}, function (activationKey) {
-            $scope.$broadcast('activationKey.loaded', activationKey);
             $scope.panel.loading = false;
+            $scope.originalEnvironment = activationKey.environment;
         }, function (response) {
             $scope.panel.loading = false;
             ApiErrorHandler.handleGETRequestErrors(response, $scope);
@@ -64,6 +64,7 @@ angular.module('Bastion.activation-keys').controller('ActivationKeyDetailsContro
 
             activationKey.$update(function (response) {
                 deferred.resolve(response);
+                $scope.originalEnvironment = activationKey.environment;
                 Notification.setSuccessMessage(translate('Activation Key updated'));
             }, function (response) {
                 deferred.reject(response);

data/engines/bastion_katello/app/assets/javascripts/bastion_katello/content-views/details/views/content-view-details.html

@@ -13,7 +13,7 @@
   </div>
 
   <nav data-block="item-actions">
-    <button type="button" class="btn btn-primary" ng-hide="denied('publish_content_views', contentView) || contentView.import_only"
+    <button type="button" class="btn btn-primary" ng-hide="denied('publish_content_views', contentView) || contentView.import_only" 
             ui-sref="content-view.publish">
       <span translate>Publish New Version</span>
     </button>

data/lib/katello/tasks/clean_backend_objects.rake

@@ -4,27 +4,18 @@ namespace :katello do
     class BackendCleaner
       def initialize
         @candlepin_uuids = []
-        @pulp_uuids = []
         @katello_candlepin_uuids = []
-        @katello_pulp_uuids = []
       end
 
       def populate!
         @candlepin_uuids = Katello::Resources::Candlepin::Consumer.all_uuids
         @katello_candlepin_uuids = Katello::Host::SubscriptionFacet.pluck(:uuid).compact
-
-        @pulp_uuids = ::Katello.pulp_server.extensions.consumer.retrieve_all.map { |consumer| consumer['id'] }
-        @katello_pulp_uuids = Katello::Host::ContentFacet.pluck(:uuid).compact
       end
 
       def hosts_with_no_subscriptions
         ::Host.where(:id => Katello::Host::SubscriptionFacet.where(:uuid => @katello_candlepin_uuids - @candlepin_uuids).select(:host_id))
       end
 
-      def hosts_with_no_content
-        ::Host.where(:id => Katello::Host::ContentFacet.where(:uuid => @katello_pulp_uuids - @pulp_uuids).select(:host_id))
-      end
-
       def hosts_with_nil_facets
         nil_sub = Katello::Host::SubscriptionFacet.where(:uuid => nil).select(:host_id).to_sql
         ::Host.where(" id in (#{nil_sub})")
@@ -33,10 +24,6 @@ namespace :katello do
       def cp_orphaned_host_uuids
         @candlepin_uuids - @katello_candlepin_uuids
       end
-
-      def pulp_orphaned_host_uuids
-        @pulp_uuids - @katello_pulp_uuids
-      end
     end
 
     def cleanup_hosts(cleaner)
@@ -49,11 +36,6 @@ namespace :katello do
         print "Host #{host.id} #{host.name} #{host.subscription_facet.try(:uuid)} is partially missing subscription information.  Un-registering\n"
         execute("Failed to delete host") { Katello::RegistrationManager.unregister_host(host, host_unregister_options(host)) }
       end
-
-      cleaner.hosts_with_no_content.each do |host|
-        print "Host #{host.id} #{host.name} #{host.content_facet.try(:uuid)} is partially missing content information.  Un-registering\n"
-        execute("Failed to delete host") { Katello::RegistrationManager.unregister_host(host, host_unregister_options(host)) }
-      end
     end
 
     def clean_backend_orphans(cleaner)
@@ -63,13 +45,6 @@ namespace :katello do
       cp_uuids.each do |consumer_id|
         execute("exception when destroying candlepin consumer #{consumer_id}") { Katello::Resources::Candlepin::Consumer.destroy(consumer_id) }
       end
-
-      pulp_uuids = cleaner.pulp_orphaned_host_uuids
-      print "#{pulp_uuids.count} orphaned consumer id(s) found in pulp.\n"
-      print "Pulp orphaned consumers: #{pulp_uuids}\n"
-      pulp_uuids.each do |consumer_id|
-        execute("exception when destroying pulp consumer #{consumer_id}") { Katello.pulp_server.extensions.consumer.delete(consumer_id) }
-      end
     end
 
     def host_unregister_options(host)

data/lib/katello/version.rb

@@ -1,3 +1,3 @@
 module Katello
-  VERSION = "4.1.0.rc1.1".freeze
+  VERSION = "4.1.0.rc2".freeze
 end

data/webpack/components/RoutedTabs/RoutedTabs.js

@@ -24,7 +24,7 @@ const RoutedTabs = ({
     if (matchedTab) {
       history.push(buildLink(matchedTab.key));
     } else {
-      history.push(buildLink(tabs[defaultTabIndex].key)); // go to first tab if no tab selected
+      history.replace(buildLink(tabs[defaultTabIndex].key)); // go to first tab if no tab selected
     }
   };
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katello
 version: !ruby/object:Gem::Version
-  version: 4.1.0.rc1.1
+  version: 4.1.0.rc2
 platform: ruby
 authors:
 - N/A
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-17 00:00:00.000000000 Z
+date: 2021-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -140,16 +140,16 @@ dependencies:
   name: qpid_proton
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.34'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.34'
 - !ruby/object:Gem::Dependency
   name: stomp
   requirement: !ruby/object:Gem::Requirement