katello 3.17.0.rc1 → 3.17.0.rc2

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

@@ -7,10 +7,10 @@ module Actions
           upload_actions = options.fetch(:upload_actions, nil)
           content_type = options.fetch(:content_type)
           if content_type
-            unit_type_id = SmartProxy.pulp_master.content_service(content_type)::CONTENT_TYPE
+            unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
           else
             content_type = repository.content_type
-            unit_type_id = SmartProxy.pulp_master.content_service(content_type)::CONTENT_TYPE
+            unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
           end
           generate_metadata = options.fetch(:generate_metadata, true)
           plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => import_upload_task) if generate_metadata

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

@@ -6,7 +6,7 @@ module Actions
         include Actions::Katello::PulpSelector
         def plan(repository, uploads, options = {})
           action_subject(repository)
-          repo_service = repository.backend_service(::SmartProxy.pulp_master)
+          repo_service = repository.backend_service(::SmartProxy.pulp_primary)
 
           upload_ids = uploads.pluck('id')
           unit_keys = repo_service.unit_keys(uploads)
@@ -14,7 +14,7 @@ module Actions
           sync_capsule = options.fetch(:sync_capsule, true)
 
           options[:content_type] ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
-          unit_type_id = SmartProxy.pulp_master.content_service(options[:content_type])::CONTENT_TYPE
+          unit_type_id = SmartProxy.pulp_primary.content_service(options[:content_type])::CONTENT_TYPE
 
           sequence do
             upload_results = concurrence do
@@ -29,7 +29,7 @@ module Actions
                 }
                 import_upload = plan_pulp_action([Actions::Pulp::Repository::ImportUpload,
                                                   Actions::Pulp3::Orchestration::Repository::ImportUpload],
-                                  repository, SmartProxy.pulp_master, import_upload_args)
+                                  repository, SmartProxy.pulp_primary, import_upload_args)
                 plan_action(FinishUpload, repository, :import_upload_task => import_upload.output,
                             generate_metadata: false, content_type: options[:content_type])
                 import_upload.output

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

@@ -9,7 +9,7 @@ module Actions
           force = options.fetch(:force, false)
           source_repository = options.fetch(:source_repository, nil)
           source_repository ||= repository.target_repository if repository.link?
-          smart_proxy = options.fetch(:smart_proxy, SmartProxy.pulp_master)
+          smart_proxy = options.fetch(:smart_proxy, SmartProxy.pulp_primary)
           matching_content = options.fetch(:matching_content, false)
 
           plan_pulp_action([Pulp::Repository::DistributorPublish, Pulp3::Orchestration::Repository::GenerateMetadata],

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

@@ -12,7 +12,7 @@ module Actions
             if copy_contents
               plan_action(Pulp3::Orchestration::Repository::MultiCopyAllUnits,
                           extended_repo_mapping,
-                          SmartProxy.pulp_master,
+                          SmartProxy.pulp_primary,
                           solve_dependencies: solve_dependencies)
             end
 
@@ -46,19 +46,15 @@ module Actions
 
           plan_action(Katello::Repository::MetadataGenerate, new_repository, metadata_options)
           unless source_repositories.first.saved_checksum_type == new_repository.saved_checksum_type
-            checksum_mapping = {}
-            repository_mapping.each do |source_repos, dest_repo|
-              checksum_mapping[dest_repo.id] = source_repos.first.saved_checksum_type
-            end
-            plan_self(:checksum_mapping => checksum_mapping)
+            plan_self(:source_checksum_type => source_repositories.first.saved_checksum_type,
+                      :target_repo_id => new_repository.id)
           end
         end
 
         def finalize
-          input[:checksum_mapping].each do |repo_id, checksum_type|
-            repository = ::Katello::Repository.find(repo_id)
-            repository.update!(saved_checksum_type: checksum_type) if (repository && checksum_type)
-          end
+          repository = ::Katello::Repository.find(input[:target_repo_id])
+          source_checksum_type = input[:source_checksum_type]
+          repository.update!(saved_checksum_type: source_checksum_type) if (repository && source_checksum_type)
         end
       end
     end

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

@@ -8,7 +8,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:id])
-          repo.backend_service(SmartProxy.pulp_master).purge_empty_contents
+          repo.backend_service(SmartProxy.pulp_primary).purge_empty_contents
         end
       end
     end

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

@@ -27,7 +27,7 @@ module Actions
             pulp_action = plan_pulp_action(
               [Pulp::Orchestration::Repository::RemoveUnits,
                Pulp3::Orchestration::Repository::RemoveUnits],
-              repository, SmartProxy.pulp_master, remove_content_args)
+              repository, SmartProxy.pulp_primary, remove_content_args)
             return if pulp_action.error
             plan_self(:content_unit_class => content_units.first.class.name, :content_unit_ids => content_unit_ids)
             plan_action(CapsuleSync, repository) if sync_capsule

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

@@ -34,38 +34,47 @@ module Actions
 
           pulp_sync_options = {}
           pulp_sync_options[:download_policy] = ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND if validate_contents && repo.yum?
+
+          #pulp2 options
           pulp_sync_options[:force_full] = true if skip_metadata_check && repo.yum?
           pulp_sync_options[:repair_sync] = true if validate_contents && repo.deb?
           pulp_sync_options[:remove_missing] = false if incremental
+          pulp_sync_options[:source_url] = source_url
+
+          #pulp3 options
+          pulp_sync_options[:optimize] = false if skip_metadata_check && repo.yum?
 
           sequence do
-            plan_action(Pulp::Repository::RemoveUnits, :repo_id => repo.id, :content_unit_type => ::Katello::YumMetadataFile::CONTENT_TYPE) if validate_contents && repo.yum?
-            sync_args = {:smart_proxy_id => SmartProxy.pulp_master.id, :repo_id => repo.id, :source_url => source_url, :options => pulp_sync_options}
-            sync_action = plan_pulp_action([Actions::Pulp::Orchestration::Repository::Sync,
-                                            Actions::Pulp3::Orchestration::Repository::Sync],
-                                           repo,
-                                           SmartProxy.pulp_master,
-                                           sync_args)
-            output = sync_action.output
-
-            contents_changed = skip_metadata_check || output[:contents_changed]
-
-            plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
-            plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
-            plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
-            plan_action(Katello::Repository::CorrectChecksum, repo)
-            concurrence do
-              plan_action(Pulp::Repository::Download, :pulp_id => repo.pulp_id, :options => {:verify_all_units => true}) if validate_contents && repo.yum?
-              plan_action(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check && repo.yum?
-              plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
-              if generate_applicability
-                regenerate_applicability(repo, contents_changed)
+            if SmartProxy.pulp_primary.pulp3_support?(repo) && validate_contents
+              plan_action(Katello::Repository::VerifyChecksum, repo)
+            else
+              plan_action(Pulp::Repository::RemoveUnits, :repo_id => repo.id, :content_unit_type => ::Katello::YumMetadataFile::CONTENT_TYPE) if validate_contents && repo.yum?
+              sync_action = plan_pulp_action([Actions::Pulp::Orchestration::Repository::Sync,
+                                              Actions::Pulp3::Orchestration::Repository::Sync],
+                                             repo,
+                                             SmartProxy.pulp_primary,
+                                             pulp_sync_options)
+              output = sync_action.output
+
+              contents_changed = skip_metadata_check || output[:contents_changed]
+
+              plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
+              plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
+              plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
+              plan_action(Katello::Repository::CorrectChecksum, repo)
+              concurrence do
+                plan_action(Pulp::Repository::Download, :pulp_id => repo.pulp_id, :options => {:verify_all_units => true}) if validate_contents && repo.yum?
+                plan_action(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check && repo.yum?
+                plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
+                if generate_applicability
+                  regenerate_applicability(repo, contents_changed)
+                end
               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
+              plan_action(Katello::Repository::SyncHook, :id => repo.id)
             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
-            plan_action(Katello::Repository::SyncHook, :id => repo.id)
           end
         end
 
@@ -91,6 +100,7 @@ module Actions
         def presenter
           found = all_planned_actions(Pulp::Repository::Sync)
           found = all_planned_actions(Pulp3::Repository::Sync) if found.empty?
+          found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?
           Helpers::Presenter::Delegated.new(self, found)
         end
 

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

@@ -3,13 +3,14 @@ module Actions
     module Repository
       class Update < Actions::EntryAction
         include Actions::Katello::PulpSelector
+
+        # rubocop:disable Metrics/MethodLength
         def plan(root, repo_params)
           repository = root.library_instance
           action_subject root.library_instance
 
           repo_params[:url] = nil if repo_params[:url] == ''
-          update_cv_cert_protected = (repo_params[:unprotected] != repository.unprotected)
-          update_auto_enabled = repo_params.key?(:auto_enabled) && (repo_params[:auto_enabled] != root.auto_enabled)
+          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
@@ -21,33 +22,43 @@ module Actions
           end
 
           if update_content?(repository)
-            plan_action(Katello::Repository::ContentUpdate, repository,
-                        update_auto_enabled: update_auto_enabled)
-          end
+            content = root.content
 
+            plan_action(::Actions::Candlepin::Product::ContentUpdate,
+                        :owner => repository.organization.label,
+                        :content_id => root.content_id,
+                        :name => root.name,
+                        :content_url => root.custom_content_path,
+                        :gpg_key_url => repository.yum_gpg_key_url,
+                        :label => content.label,
+                        :type => root.content_type,
+                        :arches => root.format_arches)
+
+            content.update!(name: root.name,
+                                       content_url: root.custom_content_path,
+                                       content_type: repository.content_type,
+                                       label: content.label,
+                                       gpg_url: repository.yum_gpg_key_url)
+          end
           if root.pulp_update_needed?
-            plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
-                              ::Actions::Pulp3::Orchestration::Repository::Update],
-                             repository,
-                             SmartProxy.pulp_master)
-            plan_self(:repository_id => root.library_instance.id, :update_cv_cert_protected => update_cv_cert_protected)
+            sequence do
+              plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
+                                ::Actions::Pulp3::Orchestration::Repository::Update],
+                               repository,
+                               SmartProxy.pulp_primary)
+              plan_self(:repository_id => root.library_instance.id)
+              if update_cv_cert_protected
+                plan_optional_pulp_action([::Actions::Pulp3::Orchestration::Repository::TriggerUpdateRepoCertGuard], repository, ::SmartProxy.pulp_primary)
+              end
+            end
           end
         end
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
-          output[:repository_id] = input[:repository_id]
-          output[:update_cv_cert_protected] = input[:update_cv_cert_protected]
           ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
         end
 
-        def finalize
-          repository = ::Katello::Repository.find(output[:repository_id])
-          if output[:update_cv_cert_protected]
-            ForemanTasks.async_task(::Actions::Katello::Repository::UpdateCVRepoCertGuard, repository, SmartProxy.pulp_master)
-          end
-        end
-
         private
 
         def update_content?(repository)

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

@@ -9,7 +9,7 @@ module Actions
             [Actions::Pulp::Orchestration::Repository::Refresh,
              Actions::Pulp3::Repository::UpdateRemote],
             repository,
-            SmartProxy.pulp_master)
+            SmartProxy.pulp_primary)
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Actions
             plan_action(Katello::Repository::MetadataGenerate, repository)
             concurrence do
               ::SmartProxy.with_repo(repository).each do |capsule|
-                next if capsule.pulp_master?
+                next if capsule.pulp_primary?
                 plan_action(Katello::CapsuleContent::Sync, capsule, repository_id: repository.id)
               end
             end

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

@@ -12,7 +12,7 @@ module Actions
           tmp_files = prepare_tmp_files(files)
 
           content_type ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
-          unit_type_id = SmartProxy.pulp_master.content_service(content_type)::CONTENT_TYPE
+          unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
           upload_actions = []
           sequence do
             concurrence do
@@ -20,7 +20,7 @@ module Actions
                 sequence do
                   upload_action = plan_pulp_action([Pulp::Orchestration::Repository::UploadContent,
                                                     Pulp3::Orchestration::Repository::UploadContent],
-                                                   repository, SmartProxy.pulp_master!, file, unit_type_id)
+                                                   repository, SmartProxy.pulp_primary!, file, unit_type_id)
 
                   upload_actions << upload_action.output
                 end

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

@@ -0,0 +1,28 @@
+module Actions
+  module Katello
+    module Repository
+      class VerifyChecksum < Actions::EntryAction
+        include Helpers::Presenter
+        include Actions::Katello::PulpSelector
+
+        def plan(repo)
+          action_subject(repo)
+
+          if SmartProxy.pulp_primary.pulp3_support?(repo)
+            plan_action(Actions::Pulp3::Repository::Repair, repo.id, SmartProxy.pulp_primary)
+          else
+            options = {}
+            options[:validate_contents] = true
+            plan_action(Actions::Katello::Repository::Sync, repo, nil, options)
+          end
+        end
+
+        def presenter
+          found = all_planned_actions(Katello::Repository::Sync)
+          found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?
+          Helpers::Presenter::Delegated.new(self, found)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp/content_view_puppet_environment/copy_contents.rb

@@ -28,7 +28,7 @@ module Actions
           target_env = ::Katello::ContentViewPuppetEnvironment.find(input[:target_content_view_puppet_environment_id])
 
           puppet_modules = input[:puppet_module_ids] ? ::Katello::PuppetModule.where(:id => input[:puppet_module_ids]) : nil
-          source_repository.backend_service(SmartProxy.pulp_master).copy_contents(target_env.nonpersisted_repository, puppet_modules: puppet_modules)
+          source_repository.backend_service(SmartProxy.pulp_primary).copy_contents(target_env.nonpersisted_repository, puppet_modules: puppet_modules)
         end
       end
     end

data/app/lib/actions/pulp/orchestration/orphan_cleanup/remove_orphans.rb

@@ -5,7 +5,7 @@ module Actions
         class RemoveOrphans < Pulp::Abstract
           def plan(proxy)
             sequence do
-              plan_action(Actions::Pulp::OrphanCleanup::RemoveUnneededRepos, proxy) unless proxy.pulp_master?
+              plan_action(Actions::Pulp::OrphanCleanup::RemoveUnneededRepos, proxy) unless proxy.pulp_primary?
               plan_action(Actions::Pulp::OrphanCleanup::RemoveOrphans, proxy)
             end
           end

data/app/lib/actions/pulp/orchestration/repository/sync.rb

@@ -4,8 +4,9 @@ module Actions
       module Repository
         class Sync < Pulp::Abstract
           include Actions::Helpers::OutputPropagator
-          def plan(_repository, _smart_proxy, options)
+          def plan(repository, smart_proxy, options)
             sequence do
+              options.merge!(:repo_id => repository.id, :smart_proxy_id => smart_proxy.id)
               action_output = plan_action(Actions::Pulp::Repository::Sync, options).output
               plan_self(:subaction_output => action_output)
             end

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

@@ -19,7 +19,7 @@ module Actions
           target_repo = ::Katello::Repository.find(input[:target_repo_id])
           filters = ::Katello::ContentViewFilter.where(:id => input[:filter_ids])
 
-          source_repo.backend_service(SmartProxy.pulp_master).copy_contents(target_repo,
+          source_repo.backend_service(SmartProxy.pulp_primary).copy_contents(target_repo,
                                                                             filters: filters,
                                                                             solve_dependencies: input[:solve_dependencies],
                                                                             rpm_filenames: input[:rpm_filenames])

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

@@ -16,7 +16,7 @@ module Actions
           source_repo = ::Katello::Repository.find(input[:source_repo_id])
           target_repo = ::Katello::Repository.find(input[:target_repo_id])
           units = input[:class_name].constantize.where(:id => input[:unit_ids])
-          source_repo.backend_service(SmartProxy.pulp_master).copy_units(target_repo, units,
+          source_repo.backend_service(SmartProxy.pulp_primary).copy_units(target_repo, units,
                                                                           incremental_update: input[:incremental_update])
         end
       end

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

@@ -9,7 +9,7 @@ module Actions
           param :capsule_id
         end
 
-        def plan(repository, smart_proxy = SmartProxy.pulp_master!)
+        def plan(repository, smart_proxy = SmartProxy.pulp_primary!)
           if repository.is_a?(::Katello::ContentViewPuppetEnvironment)
             plan_self(:content_view_puppet_environment_id => repository.id, :capsule_id => smart_proxy.id)
           else

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

@@ -19,7 +19,7 @@ module Actions
             Rails.logger.warn("Tried to delete repository #{input[:repository_id]}, but it did not exist.")
             return []
           end
-          capsule = input[:capsule_id] ? smart_proxy(input[:capsule_id]) : SmartProxy.pulp_master
+          capsule = input[:capsule_id] ? smart_proxy(input[:capsule_id]) : SmartProxy.pulp_primary
           output[:pulp_tasks] = repo.backend_service(capsule).delete
         end
       end

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

@@ -24,11 +24,11 @@ module Actions
               units = content_type.model_class.where(:id => input[:contents])
               unit_pulp_ids = units.map(&:pulp_id).sort
             end
-            tasks << ::SmartProxy.pulp_master.content_service(content_type).remove(repo, unit_pulp_ids)
+            tasks << ::SmartProxy.pulp_primary.content_service(content_type).remove(repo, unit_pulp_ids)
           else
             repo_content_types = ::Katello::RepositoryTypeManager.find(repo.content_type).content_types
             repo_content_types.each do |type|
-              tasks << ::SmartProxy.pulp_master.content_service(type).remove(repo)
+              tasks << ::SmartProxy.pulp_primary.content_service(type).remove(repo)
             end
           end
           tasks

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

@@ -14,9 +14,10 @@ module Actions
           overrides = {}
           overrides[:feed] = input[:source_url] if input[:source_url]
           overrides[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
-          overrides[:options] = input[:options] if input[:options]
+          overrides.merge(input[:options]) if input[:options]
           repo = ::Katello::Repository.find(input[:repo_id])
-          output[:pulp_tasks] = repo.backend_service(::SmartProxy.pulp_master).sync(overrides)
+
+          output[:pulp_tasks] = repo.backend_service(::SmartProxy.pulp_primary).sync(overrides)
         end
 
         def finalize

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

@@ -11,7 +11,9 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.sync
+          sync_options = {}
+          sync_options[:optimize] = false if sync_options[:skip_metadata_check]
+          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.sync(sync_options)
         end
 
         def rescue_strategy_for_self

data/app/lib/actions/pulp3/content_guard/refresh_all_distributions.rb

@@ -0,0 +1,19 @@
+module Actions
+  module Pulp3
+    module ContentGuard
+      class RefreshAllDistributions < Pulp3::Abstract
+        def plan(smart_proxy)
+          sequence do
+            plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy)
+
+            roots = ::Katello::RootRepository.where.not(:content_type => ::Katello::Repository::DOCKER_TYPE).where(:unprotected => false)
+            repositories = ::Katello::Repository.where(:root => roots)
+            if repositories.any?
+              plan_action(::Actions::BulkAction, Actions::Pulp3::Repository::RefreshDistribution, repositories, smart_proxy.id, assume_content_guard_exists: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end