katello 3.17.0 → 3.18.0

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

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class ImportLibrary < Actions::EntryAction
+        def plan(organization, path:, metadata:)
+          action_subject(organization)
+          library_view = ::Katello::Pulp3::ContentViewVersion::Import.find_or_create_library_import_view(organization)
+          plan_action(::Actions::Katello::ContentViewVersion::Import, library_view, path: path, metadata: metadata)
+        end
+
+        def humanized_name
+          _("Import Default Content View")
+        end
+      end
+    end
+  end
+end

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/hypervisors_update.rb

@@ -13,6 +13,8 @@ module Actions
           @hypervisors = input[:hypervisors]
           return unless @hypervisors
 
+          @duplicate_uuid_hypervisors = {}
+
           User.as_anonymous_admin do
             ActiveRecord::Base.transaction do
               load_resources
@@ -30,8 +32,16 @@ module Actions
               update_facts(uuid, host)
             end
           end
+
+          @duplicate_uuid_hypervisors.each do |hypervisor, existing_host|
+            fail _("Host creation was skipped for %s because it shares a BIOS UUID with %s. " \
+                   "To report this hypervisor, override its dmi.system.uuid fact or set 'candlepin.use_system_uuid_for_matching' " \
+                   "to 'true' in the Candlepin configuration." % [hypervisor[:name], existing_host.name])
+          end
         end
 
+        private
+
         def load_hosts_guests
           @hosts.each do |uuid, host|
             host.subscription_facet ||= host.build_subscription_facet(uuid: uuid)
@@ -81,6 +91,14 @@ module Actions
           @hypervisors.each do |hypervisor|
             next if @hosts.key?(hypervisor[:uuid])
 
+            created_host = new_hypervisors[hypervisor[:uuid]]
+            if created_host
+              # we've already created a host record for this duplicate hypervisor
+              # track it so we can message later, and continue processing the remaining hypervisors
+              @duplicate_uuid_hypervisors[hypervisor] = created_host
+              next
+            end
+
             duplicate_name, org = duplicate_name(hypervisor, @candlepin_attributes[hypervisor[:uuid]])
             new_hypervisors[hypervisor[:uuid]] = create_host_for_hypervisor(duplicate_name, org)
           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/host/upload_package_profile.rb

@@ -39,7 +39,9 @@ module Actions
             Rails.logger.warn("Host with ID %s has no content facet, continuing" % host_id)
           else
             begin
-              ::Katello::Pulp::Consumer.new(host.content_facet.uuid).upload_package_profile(profile)
+              if SmartProxy.pulp_primary&.has_feature?(SmartProxy::PULP_FEATURE)
+                ::Katello::Pulp::Consumer.new(host.content_facet.uuid).upload_package_profile(profile)
+              end
               simple_packages = profile.map { |item| ::Katello::Pulp::SimplePackage.new(item) }
               host.import_package_profile(simple_packages)
             rescue RestClient::ResourceNotFound

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

@@ -60,12 +60,14 @@ module Actions
 
           module_stream_profile = updated_profiles + unassociated_profiles
 
-          unless module_stream_profile.empty?
-            begin
-              ::Katello::Pulp::Consumer.new(host.content_facet.uuid).
-                upload_module_stream_profile(module_stream_profile)
-            rescue RestClient::ResourceNotFound
-              Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % host.id)
+          if SmartProxy.pulp_primary&.has_feature?(SmartProxy::PULP_FEATURE)
+            unless module_stream_profile.empty?
+              begin
+                ::Katello::Pulp::Consumer.new(host.content_facet.uuid).
+                  upload_module_stream_profile(module_stream_profile)
+              rescue RestClient::ResourceNotFound
+                Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % host.id)
+              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]

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

@@ -4,8 +4,10 @@ module Actions
     module Repository
       class ImportUpload < Actions::EntryAction
         include Actions::Katello::PulpSelector
+        # rubocop:disable Metrics/MethodLength
         def plan(repository, uploads, options = {})
           action_subject(repository)
+          repository.clear_smart_proxy_sync_histories
           repo_service = repository.backend_service(::SmartProxy.pulp_primary)
 
           upload_ids = uploads.pluck('id')
@@ -23,10 +25,11 @@ module Actions
                 import_upload_args = {
                   pulp_id: repository.pulp_id,
                   unit_type_id: unit_type_id,
-                  unit_key: unit_key,
+                  unit_key: unit_key.with_indifferent_access,
                   upload_id: upload_id,
                   unit_metadata: unit_metadata
                 }
+
                 import_upload = plan_pulp_action([Actions::Pulp::Repository::ImportUpload,
                                                   Actions::Pulp3::Orchestration::Repository::ImportUpload],
                                   repository, SmartProxy.pulp_primary, import_upload_args)

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

@@ -23,7 +23,7 @@ module Actions
             remove_content_args = {
               :contents => content_unit_ids,
               :content_unit_type => content_unit_type}
-
+            repository.clear_smart_proxy_sync_histories
             pulp_action = plan_pulp_action(
               [Pulp::Orchestration::Repository::RemoveUnits,
                Pulp3::Orchestration::Repository::RemoveUnits],

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

@@ -79,7 +79,9 @@ module Actions
         end
 
         def run
-          ForemanTasks.async_task(Repository::CapsuleSync, ::Katello::Repository.find(input[:id])) if Setting[:foreman_proxy_content_auto_sync]
+          repo = ::Katello::Repository.find(input[:id])
+          repo.clear_smart_proxy_sync_histories if input[:contents_changed]
+          ForemanTasks.async_task(Repository::CapsuleSync, repo) if Setting[:foreman_proxy_content_auto_sync]
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 

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

@@ -11,6 +11,7 @@ module Actions
 
           repo_params[:url] = nil if repo_params[:url] == ''
           update_cv_cert_protected = repo_params.key?(:unprotected) && (repo_params[:unprotected] != repository.unprotected)
+
           root.update!(repo_params)
 
           if root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
@@ -32,7 +33,9 @@ module Actions
                         :gpg_key_url => repository.yum_gpg_key_url,
                         :label => content.label,
                         :type => root.content_type,
-                        :arches => root.format_arches)
+                        :arches => root.format_arches,
+                        :os_versions => root.os_versions&.join(',')
+                      )
 
             content.update!(name: root.name,
                                        content_url: root.custom_content_path,
@@ -57,6 +60,7 @@ module Actions
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
           ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
+          repository.clear_smart_proxy_sync_histories
         end
 
         private

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

@@ -9,6 +9,7 @@ module Actions
         include Actions::Katello::PulpSelector
         def plan(repository, files, content_type = nil)
           action_subject(repository)
+          repository.clear_smart_proxy_sync_histories
           tmp_files = prepare_tmp_files(files)
 
           content_type ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label

data/app/lib/actions/middleware/record_smart_proxy_sync_history.rb

@@ -0,0 +1,15 @@
+module Actions
+  module Middleware
+    class RecordSmartProxySyncHistory < Dynflow::Middleware
+      def run(*args)
+        if (action.input[:repository_id] && (action.input[:smart_proxy_id] || action.input[:capsule_id]) && !self.action.output[:smart_proxy_history_id])
+          repo = ::Katello::Repository.find(action.input[:repository_id])
+          smart_proxy_id = action.input[:smart_proxy_id] || action.input[:capsule_id]
+          smart_proxy = ::SmartProxy.find(smart_proxy_id)
+          self.action.output[:smart_proxy_history_id] = repo.create_smart_proxy_sync_history(smart_proxy)
+        end
+        pass(*args)
+      end
+    end
+  end
+end

data/app/lib/actions/pulp/consumer/sync_capsule.rb

@@ -2,14 +2,16 @@ module Actions
   module Pulp
     module Consumer
       class SyncCapsule < ::Actions::Pulp::AbstractAsyncTask
+        include ::Actions::Helpers::SmartProxySyncHistoryHelper
         input_format do
           param :capsule_id, Integer
           param :repo_pulp_id, String
+          param :repository_id, Integer
           param :sync_options
         end
 
         def plan(repository, smart_proxy, options)
-          plan_self(:capsule_id => smart_proxy.id, :repo_pulp_id => repository.pulp_id, :sync_options => options)
+          plan_self(:capsule_id => smart_proxy.id, :repo_pulp_id => repository.pulp_id, :repository_id => repository.id, :sync_options => options)
         end
 
         def humanized_name
@@ -17,7 +19,7 @@ module Actions
         end
 
         def invoke_external_task
-          pulp_resources.repository.sync(input[:repo_pulp_id], override_config: input[:sync_options])
+          output[:pulp_tasks] = pulp_resources.repository.sync(input[:repo_pulp_id], override_config: input[:sync_options])
         end
 
         def run_progress

data/app/lib/actions/pulp/repository/distributor_publish.rb

@@ -20,7 +20,7 @@ module Actions
           else
             repo = ::Katello::ContentViewPuppetEnvironment.find_by(:id => input[:content_view_puppet_environment_id]).nonpersisted_repository
           end
-
+          repo.clear_smart_proxy_sync_histories if smart_proxy(input[:smart_proxy_id]).pulp_primary?
           repo.backend_service(smart_proxy(input[:smart_proxy_id])).distributor_publish(input[:options])
         end
 

data/app/lib/actions/pulp3/capsule_content/sync.rb

@@ -2,6 +2,7 @@ module Actions
   module Pulp3
     module CapsuleContent
       class Sync < Pulp3::AbstractAsyncTask
+        include ::Actions::Helpers::SmartProxySyncHistoryHelper
         def plan(repository, smart_proxy, options = {})
           sequence do
             plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :options => options)

data/app/lib/actions/pulp3/content_migration.rb

@@ -1,6 +1,8 @@
 module Actions
   module Pulp3
     class ContentMigration < Pulp3::AbstractAsyncTask
+      include Helpers::Presenter
+
       def plan(smart_proxy, options)
         sequence do
           action = plan_self(smart_proxy_id: smart_proxy.id)
@@ -13,6 +15,14 @@ module Actions
         migration_service.create_and_run_migrations
       end
 
+      def humanized_name
+        _("Content Migration")
+      end
+
+      def presenter
+        Actions::Pulp3::ContentMigrationPresenter.new(self)
+      end
+
       def rescue_strategy
         Dynflow::Action::Rescue::Skip
       end

data/app/lib/actions/pulp3/content_migration_presenter.rb

@@ -0,0 +1,59 @@
+require 'katello/content_migration_progress'
+
+module Actions
+  module Pulp3
+    class ContentMigrationPresenter < Helpers::Presenter::Base
+      def initialize(migration_action)
+        @migration_action = migration_action
+      end
+
+      def humanized_output
+        if !@migration_action.done?
+          ContentMigrationTaskPresenter.new(@migration_action).humanized_output
+        else
+          task = ForemanTasks::Task.find_by(:external_id => @migration_action.execution_plan_id)
+          ::Katello::ContentMigrationProgress.find_by(:task_id => task.id)&.progress_message
+        end
+      end
+
+      class ContentMigrationTaskPresenter
+        def initialize(action)
+          @action = action
+        end
+
+        def task_progress_reports
+          if @action.pulp_tasks.empty?
+            []
+          else
+            @action.pulp_tasks[0].progress_reports
+          end
+        end
+
+        def task_group_progress_reports
+          if @action.task_groups.empty?
+            []
+          else
+            @action.task_groups[0].group_progress_reports
+          end
+        end
+
+        def humanized_output
+          report = task_progress_reports.find { |current| current['state'] == 'running' && current['total'] != 0 }
+          report ||= task_group_progress_reports.find { |current| current['total'] != 0 && current['done'] != current['total'] }
+
+          if !report.blank? && report['total'] != 0
+            "#{report['message']} #{report['done']}/#{report['total']}"
+          elsif report
+            report['message']
+          elsif task_progress_reports.empty?
+            "Content migration starting. "
+          else
+            "Initial Migration steps complete."
+          end
+        rescue
+          ""
+        end
+      end
+    end
+  end
+end