katello 3.18.0.rc2.1 → 3.18.2.1

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

@@ -267,8 +267,9 @@ module Katello
     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
-    param :errata_ids, Array, :desc => N_("List of Errata ids")
+    param :errata_ids, Array, :desc => N_("List of Errata ids"), :required => true
     def available_incremental_updates
+      fail HttpErrors::BadRequest, _("errata_ids is a required parameter") if params[:errata_ids].empty?
       version_environments = {}
       content_facets = Katello::Host::ContentFacet.with_non_installable_errata(@errata, @hosts)
 

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

@@ -95,6 +95,7 @@ module Katello
     param :available_for, String, :desc => N_("interpret specified object to return only Repositories that can be associated with specified object.  Only 'content_view' & 'content_view_version' are supported."),
           :required => false
     param :with_content, RepositoryTypeManager.enabled_content_types, :desc => N_("only repositories having at least one of the specified content type ex: rpm , erratum")
+    param :download_policy, ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES, :desc => N_("limit to only repositories with this download policy")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Repository)
     def index
@@ -138,6 +139,7 @@ module Katello
     def index_relation_product(query)
       query = query.joins(:root => :product).where("#{Product.table_name}.organization_id" => @organization) if @organization
       query = query.joins(:root).where("#{RootRepository.table_name}.product_id" => @product.id) if @product
+      query = query.joins(:root).where("#{RootRepository.table_name}.download_policy" => params[:download_policy]) if params[:download_policy]
       query
     end
 

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

@@ -39,7 +39,20 @@ module Katello
       end
 
       def throw_resource_not_found(name: resource_name, id: params[:id])
-        fail HttpErrors::NotFound, _("Could not find %{name} resource with id %{id}") % {id: id, name: name}
+        perms_message = "Potential missing permissions: " +
+          missing_permissions.map(&:name).join(', ')
+        fail HttpErrors::NotFound, _("Could not find %{name} resource with id %{id}. %{perms_message}") % {id: id, name: name, perms_message: perms_message}
+      end
+
+      def missing_permissions
+        missing_perms = ::Foreman::AccessControl.permissions_for_controller_action(path_to_authenticate)
+
+        # promote_or_remove_content_views_to_environments has a special relationship to promote_or_remove_content_views
+        if path_to_authenticate["controller"] == "katello/api/v2/content_view_versions" &&
+            path_to_authenticate["action"].in?(["promote", "remove_from_environment", "remove", "republish_repositories"])
+          missing_perms << ::Permission.find_by(name: "promote_or_remove_content_views_to_environments")
+        end
+        missing_perms
       end
 
       def throw_resources_not_found(name:, expected_ids: [])

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

@@ -9,8 +9,12 @@ module Actions
 
           def run
             input[:host_ids].each do |host_id|
-              content_facet = ::Host.find(host_id).content_facet
-              content_facet.calculate_and_import_applicability
+              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
             end
           end
 

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

@@ -39,7 +39,7 @@ module Actions
                                              environment:  environment,
                                              repository: repository)
           sequence do
-            plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE)
             plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy) if repositories.any? { |repo| smart_proxy.pulp3_support?(repo) }
             plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.pulp3_enabled?
             plan_action(SyncCapsule, smart_proxy, refresh_options)

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

@@ -19,9 +19,14 @@ 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/promote_to_environment.rb

@@ -71,7 +71,7 @@ module Actions
         private
 
         def sync_proxies?(environment)
-          Setting[:foreman_proxy_content_auto_sync] && ::SmartProxy.sync_needed?(environment)
+          ::SmartProxy.sync_needed?(environment)
         end
 
         def repos_to_delete(version, environment)

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

@@ -137,7 +137,7 @@ module Actions
           history.save!
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           view = ::Katello::ContentView.find(input[:content_view_id])
-          if SmartProxy.sync_needed?(environment) && Setting[:foreman_proxy_content_auto_sync] && !input[:skip_promotion]
+          if SmartProxy.sync_needed?(environment) && !input[:skip_promotion]
             ForemanTasks.async_task(ContentView::CapsuleSync,
                                     view,
                                     environment)

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

@@ -5,10 +5,11 @@ module Actions
         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 ::Katello::HttpErrors::BadRequest, _("This API endpoint is only valid for Pulp 3 repositories.")
+            fail _("This action will become available after the Pulp 3 content migration")
           end
 
           ::Katello::Pulp3::ContentViewVersion::Import.check!(content_view: content_view, metadata: metadata, path: path)
+          ::Katello::Pulp3::ContentViewVersion::Import.reset_content_view_repositories_from_metadata!(content_view: content_view, metadata: metadata)
 
           major = metadata[:content_view_version][:major]
           minor = metadata[:content_view_version][:minor]

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

@@ -352,20 +352,36 @@ module Actions
         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 = []
-          if new_repo.content_type == ::Katello::Repository::YUM_TYPE
-            unless errata_ids.blank?
+
+          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?
+          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
 

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

@@ -14,7 +14,7 @@ module Actions
             host.subscription_facet.purpose_addons = purpose_addon_objects
           end
 
-          host.subscription_facet.save!
+          host.save!
           plan_self(:hostname => host.name)
         end
 

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

@@ -72,7 +72,11 @@ module Actions
               end
               plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
                         :contents_changed => contents_changed)
-              plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed) if generate_applicability
+
+              if generate_applicability && !SETTINGS[:katello][:katello_applicability]
+                plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed)
+              end
+
               plan_action(Katello::Repository::SyncHook, :id => repo.id)
             end
           end

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

@@ -1,12 +1,32 @@
 module Actions
   module Middleware
     class RecordSmartProxySyncHistory < Dynflow::Middleware
-      def run(*args)
+      def save_smart_proxy_sync_history
         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])
+          repo_id = action.input[:repository_id]
+          repo = ::Katello::Repository.find_by(id: repo_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)
+          smart_proxy = ::SmartProxy.find_by(id: smart_proxy_id)
+
+          #skip pulp2 puppet syncs
+          if (repo_pulp_id = action.input[:repo_pulp_id])
+            return if ::Katello::ContentViewPuppetEnvironment.find_by(pulp_id: repo_pulp_id)
+          end
+
+          if repo && smart_proxy
+            self.action.output[:smart_proxy_history_id] = repo.create_smart_proxy_sync_history(smart_proxy)
+          else
+            fail "Smart Proxy could not be found with id #{smart_proxy_id}" if smart_proxy.nil?
+            fail "Repository could not be found with id #{repo_id}" if repo.nil?
+          end
+        end
+      end
+
+      def run(*args)
+        begin
+          save_smart_proxy_sync_history
+        rescue => error
+          Rails.logger.error("Error saving smart proxy history: #{error.message}")
         end
         pass(*args)
       end

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

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

@@ -0,0 +1,22 @@
+module Actions
+  module Pulp3
+    class ContentMigrationReset < Pulp3::AbstractAsyncTask
+      def plan(smart_proxy)
+        plan_self(smart_proxy_id: smart_proxy.id)
+      end
+
+      def invoke_external_task
+        migration_service = ::Katello::Pulp3::Migration.new(smart_proxy)
+        migration_service.reset
+      end
+
+      def humanized_name
+        _("Content Migration Reset")
+      end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Skip
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/content_view/delete_repository_references.rb

@@ -14,7 +14,7 @@ module Actions
           content_view.repository_references.each do |repository_reference|
             repo = repository_reference.root_repository.library_instance
             #force pulp3 in case we've done migrations, but haven't switched over yet
-            tasks << repo.backend_service(smart_proxy, true).delete(repository_reference.repository_href)
+            tasks << repo.backend_service(smart_proxy, true).delete_repository(repository_reference)
           end
           content_view.repository_references.destroy_all
 

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

@@ -15,8 +15,9 @@ module Actions
           from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
           ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
                                                    content_view_version: cvv,
-                                                   from_content_view_version: from_cvv).create_export(input[:exporter_data][:pulp_href],
-                                                                                            chunk_size: input[:chunk_size])
+                                                   from_content_view_version: from_cvv)
+                                                   .create_export(input[:exporter_data][:pulp_href],
+                                                                        chunk_size: input[:chunk_size])
         end
       end
     end

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

@@ -6,9 +6,14 @@ module Actions
       end
 
       def run
-        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_primary)
+        task_id = ForemanTasks::Task.find_by(external_id: self.execution_plan_id)&.id
+        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_primary, input.merge(task_id: task_id))
         migration_service.import_pulp3_content
       end
+
+      def humanized_output
+        output[:status]
+      end
     end
   end
 end

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

@@ -9,7 +9,8 @@ module Actions
                 sequence do
                   copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, repo, SmartProxy.pulp_primary!,
                                                     repo.library_instance,
-                                                    copy_all: true)
+                                                    copy_all: true,
+                                                    mirror: content_view_version.content_view.library_import?)
                   plan_action(Actions::Pulp3::Repository::SaveVersion, repo.library_instance,
                                 tasks: copy_action.output[:pulp_tasks])
                   plan_action(Katello::Repository::IndexContent, id: repo.library_instance_id)

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

@@ -18,7 +18,10 @@ module Actions
           end
 
           # rubocop:disable Metrics/MethodLength
-          def plan(content_view_version, destination_server:, chunk_size: nil, from_history: nil)
+          def plan(content_view_version:, destination_server: nil,
+                   chunk_size: nil, from_history: nil,
+                   validate_incremental: true,
+                   fail_on_missing_content: false)
             action_subject(content_view_version)
             unless File.directory?(Setting['pulpcore_export_destination'])
               fail ::Foreman::Exception, N_("Unable to export. 'pulpcore_export_destination' setting is not set to a valid directory.")
@@ -27,14 +30,13 @@ module Actions
             sequence do
               smart_proxy = SmartProxy.pulp_primary!
               from_content_view_version = from_history&.content_view_version
-              if from_content_view_version.present?
-                export_service = ::Katello::Pulp3::ContentViewVersion::Export.new(
-                                                       smart_proxy: smart_proxy,
-                                                       content_view_version: content_view_version,
-                                                       destination_server: destination_server,
-                                                       from_content_view_version: from_content_view_version)
-                export_service.validate_incremental_export!
-              end
+              export_service = ::Katello::Pulp3::ContentViewVersion::Export.new(
+                                                     smart_proxy: smart_proxy,
+                                                     content_view_version: content_view_version,
+                                                     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)
 
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
                                      content_view_version_id: content_view_version.id,
@@ -74,15 +76,17 @@ module Actions
                                                        content_view_version: cvv,
                                                        smart_proxy: smart_proxy,
                                                        from_content_view_version: from_cvv).generate_metadata
-            export_metadata[:incremental] = from_cvv.present?
-            toc = Dir.glob("#{path}/*toc.json").first
-            export_metadata[:toc] = File.basename(toc) if toc
-            ::Katello::ContentViewVersionExportHistory.create!(
+
+            toc_path_info = output[:exported_file_checksum].find { |item| item.first.end_with?("toc.json") }
+            export_metadata[:toc] = File.basename(toc_path_info.first)
+
+            history = ::Katello::ContentViewVersionExportHistory.create!(
               content_view_version_id: input[:content_view_version_id],
               destination_server: input[:destination_server],
               path: path,
               metadata: export_metadata
             )
+            output[:export_history_id] = history.id
           end
 
           def humanized_name