katello 4.2.1 → 4.3.0.rc1

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

@@ -0,0 +1,38 @@
+module Actions
+  module Katello
+    module CdnConfiguration
+      class Update < Actions::EntryAction
+        def plan(cdn_configuration, options)
+          cdn_configuration.update!(options)
+
+          if cdn_configuration.redhat?
+            cdn_configuration.ssl_cert = nil
+            cdn_configuration.ssl_key = nil
+          else
+            resource = ::Katello::Resources::CDN::CdnResource.create(cdn_configuration: cdn_configuration)
+            keypair = resource.debug_certificate
+            cdn_configuration.ssl_cert = OpenSSL::X509::Certificate.new(keypair)
+            cdn_configuration.ssl_key = OpenSSL::PKey::RSA.new(keypair)
+          end
+
+          cdn_configuration.save!
+
+          org = cdn_configuration.organization
+          roots = ::Katello::RootRepository.redhat.in_organization(org)
+          roots.each do |root|
+            full_path = if cdn_configuration.redhat?
+                          root.product.repo_url(root.library_instance.generate_content_path)
+                        else
+                          resource.repository_url(content_label: root.content.label)
+                        end
+            plan_action(::Actions::Katello::Repository::Update, root, url: full_path)
+          end
+        end
+
+        def humanized_name
+          _("Update CDN Configuration")
+        end
+      end
+    end
+  end
+end

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

@@ -11,8 +11,10 @@ module Actions
         # system_environment_id - environment to reassociate systems with
         # key_content_view_id - content view to reassociate actvation keys with
         # key_environment_id - environment to reassociate activation keys with'
+        # destroy_content_view - delete the CV completely along with all cv versions and environments
         # organization_destroy
         # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/CyclomaticComplexity
         def plan(content_view, options)
           cv_envs = options.fetch(:content_view_environments, [])
           versions = options.fetch(:content_view_versions, [])
@@ -58,8 +60,11 @@ module Actions
                           :skip_environment_check => true,
                           :skip_destroy_env_content => true)
             end
-
+            if options[:destroy_content_view] && SmartProxy.pulp_primary&.pulp3_enabled?
+              plan_action(Actions::Pulp3::ContentView::DeleteRepositoryReferences, content_view, SmartProxy.pulp_primary)
+            end
             plan_self(content_view_id: content_view.id,
+                      destroy_content_view: options[:destroy_content_view],
                       environment_ids: cv_envs.map(&:environment_id),
                       environment_names: cv_envs.map { |cve| cve.environment.name },
                       version_ids: versions.map(&:id),
@@ -87,17 +92,23 @@ module Actions
         end
 
         def finalize
-          input[:content_view_history_ids].each do |history_id|
-            history = ::Katello::ContentViewHistory.find_by(:id => history_id)
-            if history
-              history.status = ::Katello::ContentViewHistory::SUCCESSFUL
-              history.save!
+          if input[:destroy_content_view]
+            content_view = ::Katello::ContentView.find(input[:content_view_id])
+            content_view.content_view_repositories.each(&:destroy)
+            content_view.destroy!
+          else
+            input[:content_view_history_ids].each do |history_id|
+              history = ::Katello::ContentViewHistory.find_by(:id => history_id)
+              if history
+                history.status = ::Katello::ContentViewHistory::SUCCESSFUL
+                history.save!
+              end
             end
           end
         end
 
         def validate_options(_content_view, cv_envs, versions, options)
-          if cv_envs.empty? && versions.empty?
+          if !options[:destroy_content_view] && cv_envs.empty? && versions.empty?
             fail _("Either environments or versions must be specified.")
           end
           all_cv_envs = combined_cv_envs(cv_envs, versions)

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

@@ -21,8 +21,8 @@ module Actions
         end
 
         def finalize
-          version = ::Katello::ContentViewVersion.find(input[:id])
-          version.destroy!
+          version = ::Katello::ContentViewVersion.find_by(id: input[:id])
+          version&.destroy!
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Actions
         def plan(content_view_version)
           action_subject(content_view_version.content_view)
           plan_self(:version_id => content_view_version.id)
-          plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, content_view_version.repositories, :force => true)
+          plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, content_view_version.repositories)
         end
 
         def run

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

@@ -23,9 +23,8 @@ module Actions
             matching_content = check_matching_content(new_repository, source_repositories)
             metadata_generate(source_repositories, new_repository, filters, rpm_filenames, matching_content) if generate_metadata
 
-            index_options = {id: new_repository.id}
+            index_options = {id: new_repository.id, force_index: true}
             index_options[:source_repository_id] = source_repositories.first.id if source_repositories.count == 1 && filters.empty? && rpm_filenames.nil?
-            index_options[:matching_content] = matching_content
             plan_action(Katello::Repository::IndexContent, index_options)
           end
         end

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

@@ -8,12 +8,14 @@ module Actions
         #   skip_environment_update - defaults to false. skips updating the CP environment
         #   destroy_content - can be disabled to skip Candlepin remove_content
         def plan(repository, options = {})
+          affected_cvv_ids = []
           skip_environment_update = options.fetch(:skip_environment_update, false) ||
               options.fetch(:organization_destroy, false)
           destroy_content = options.fetch(:destroy_content, true)
+          remove_from_content_view_versions = options.fetch(:remove_from_content_view_versions, false)
           action_subject(repository)
 
-          unless repository.destroyable?
+          unless repository.destroyable?(remove_from_content_view_versions)
             # The repository is going to be deleted in finalize, but it cannot be deleted.
             # Stop now and inform the user.
             fail repository.errors.messages.values.join("\n")
@@ -23,7 +25,13 @@ module Actions
                            repository,
                            SmartProxy.pulp_primary)
 
-          plan_self(:user_id => ::User.current.id)
+          if remove_from_content_view_versions
+            library_instances_inverse = repository.library_instances_inverse
+            affected_cvv_ids = library_instances_inverse.pluck(:content_view_version_id).uniq
+            plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, library_instances_inverse)
+          end
+
+          plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids)
           sequence do
             if repository.redhat?
               handle_redhat_content(repository) unless skip_environment_update
@@ -36,9 +44,17 @@ module Actions
         end
 
         def finalize
-          repository = ::Katello::Repository.find(input[:repository][:id])
-          docker_cleanup = repository.content_type == ::Katello::Repository::DOCKER_TYPE
-          delete_record(repository, {docker_cleanup: docker_cleanup})
+          repository = ::Katello::Repository.find_by(id: input[:repository][:id])
+          if repository
+            docker_cleanup = repository.content_type == ::Katello::Repository::DOCKER_TYPE
+            delete_record(repository, {docker_cleanup: docker_cleanup})
+
+            if (affected_cvv_ids = input[:affected_cvv_ids]).any?
+              affected_cvv_ids.each do |cvv_id|
+                ::Katello::ContentViewVersion.find(cvv_id).update_content_counts!
+              end
+            end
+          end
         end
 
         def handle_custom_content(repository)

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

@@ -25,7 +25,7 @@ module Actions
 
         def needs_download?(repository)
           repository.distribution_bootable? &&
-             repository.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+             repository.download_policy == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
         end
       end
     end

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

@@ -13,7 +13,7 @@ module Actions
             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
+          plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => import_upload_task, :force_publication => true) if generate_metadata
 
           recent_range = 5.minutes.ago.utc.iso8601
           plan_action(Katello::Repository::FilteredIndexContent,

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

@@ -41,7 +41,7 @@ module Actions
                 import_upload.output
               end
             end
-            plan_action(Katello::Repository::MetadataGenerate, repository) if generate_metadata
+            plan_action(Katello::Repository::MetadataGenerate, repository, force_publication: true) if generate_metadata
             plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id]) if generate_applicability
             plan_self(repository_id: repository.id, sync_capsule: sync_capsule, upload_results: upload_results)
           end

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

@@ -2,21 +2,34 @@ module Actions
   module Katello
     module Repository
       class IndexContent < Actions::EntryAction
-        middleware.use Actions::Middleware::ExecuteIfContentsChanged
-
         input_format do
           param :id, Integer
-          param :dependency, Hash
-          param :contents_changed
-          param :matching_content
           param :source_repository_id
           param :full_index
+          param :force_index
         end
 
         def run
           source_repository = ::Katello::Repository.find(input[:source_repository_id]) if input[:source_repository_id]
           repo = ::Katello::Repository.find(input[:id])
-          repo.index_content(source_repository: source_repository, full_index: input[:full_index].present?)
+
+          initial_counts = {}
+          repo.repository_type.primary_content_types.each do |content_type|
+            initial_counts[content_type.label] = content_type.model_class.in_repositories(repo).count
+          end
+
+          if input[:force_index] || (repo.last_contents_changed >= repo.last_indexed)
+            repo.index_content(source_repository: source_repository, full_index: input[:full_index].present?)
+            repo.update(:last_indexed => DateTime.now)
+          else
+            output[:index_skipped] = true
+          end
+
+          output[:new_content] = {}
+          repo.repository_type.primary_content_types.each do |content_type|
+            new_count = content_type.model_class.in_repositories(repo).count
+            output[:new_content][content_type.label] = new_count - initial_counts[content_type.label]
+          end
         end
       end
     end

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

@@ -7,9 +7,11 @@ module Actions
           source_repository ||= repository.target_repository if repository.link?
           smart_proxy = options.fetch(:smart_proxy, SmartProxy.pulp_primary)
           matching_content = options.fetch(:matching_content, false)
+          force_publication = options.fetch(:force_publication, false)
 
           plan_action(Pulp3::Orchestration::Repository::GenerateMetadata,
                         repository, smart_proxy,
+                        :force_publication => force_publication,
                         :source_repository => source_repository,
                         :matching_content => matching_content)
         end

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

@@ -27,7 +27,7 @@ module Actions
               end
 
               extended_repo_mapping.values.each do |dest_repo_map|
-                plan_action(Katello::Repository::IndexContent, id: dest_repo_map[:dest_repo].id, matching_content: dest_repo_map[:matching_content])
+                plan_action(Katello::Repository::IndexContent, id: dest_repo_map[:dest_repo].id)
               end
             end
           end

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

@@ -42,7 +42,7 @@ module Actions
 
         def create_sub_plans
           trigger(Actions::Katello::Repository::MetadataGenerate,
-                  ::Katello::Repository.find(input[:repository][:id]))
+                  ::Katello::Repository.find(input[:repository][:id]), :force_publication => true)
         end
 
         def resource_locks

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

@@ -18,21 +18,20 @@ module Actions
         #   of Katello and we just need to finish the rest of the orchestration
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
         def plan(repo, options = {})
           action_subject(repo)
 
           source_url = options.fetch(:source_url, nil)
           validate_contents = options.fetch(:validate_contents, false)
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && repo.yum?)
-          generate_applicability =  options.fetch(:generate_applicability, repo.yum?)
+          generate_applicability =  options.fetch(:generate_applicability, repo.yum? || repo.deb?)
 
           fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
 
           pulp_sync_options = {}
-          pulp_sync_options[:download_policy] = ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND if validate_contents && repo.yum?
+          pulp_sync_options[:download_policy] = ::Katello::RootRepository::DOWNLOAD_ON_DEMAND if validate_contents && repo.yum?
 
           #pulp3 options
           pulp_sync_options[:optimize] = false if skip_metadata_check && repo.yum?
@@ -47,14 +46,11 @@ module Actions
                                         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::Repository::IndexContent, :id => repo.id, :force_index => skip_metadata_check)
               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(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check && repo.yum?
                 plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
                 plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repo.id]) if generate_applicability
               end

data/app/lib/actions/katello/repository_set/scan_cdn.rb

@@ -72,10 +72,6 @@ module Actions
                                                      content,
                                                      substitutions)
         end
-
-        def cdn_url
-          product.provider[:repository_url]
-        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Actions
           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_by(id: smart_proxy_id)
+          smart_proxy = ::SmartProxy.unscoped.find_by(id: smart_proxy_id)
 
           if repo && smart_proxy
             self.action.output[:smart_proxy_history_id] = repo.create_smart_proxy_sync_history(smart_proxy)

data/app/lib/actions/pulp/orphan_cleanup/remove_unneeded_repos.rb

@@ -7,7 +7,7 @@ module Actions
         end
 
         def invoke_external_task
-          smart_proxy_service = ::Katello::Pulp::SmartProxyRepository.new(::SmartProxy.find(input[:smart_proxy_id]))
+          smart_proxy_service = ::Katello::Pulp::SmartProxyRepository.new(::SmartProxy.unscoped.find(input[:smart_proxy_id]))
           smart_proxy_service.delete_orphaned_repos
         end
       end

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

@@ -9,7 +9,7 @@ module Actions
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repo_id])
           ::Katello::RepositoryTypeManager.find(repo.content_type).content_types.map do |type|
-            ::SmartProxy.find(input[:smart_proxy_id]).content_service(type).remove(repo)
+            ::SmartProxy.unscoped.find(input[:smart_proxy_id]).content_service(type).remove(repo)
           end
         end
       end

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

@@ -105,11 +105,20 @@ module Actions
       def check_for_errors
         combined_tasks.each do |task|
           if (message = task.error)
-            fail ::Katello::Errors::Pulp3Error, message
+            fail ::Katello::Errors::Pulp3Error, overwrite_pulp_error(message)
           end
         end
       end
 
+      def overwrite_pulp_error(message)
+        case message
+        when 'This repository uses features which are incompatible with \'mirror\' sync. Please sync without mirroring enabled.'
+          'Please disable \'mirror on sync\' because the upstream repository refers to external resources.'
+        else
+          message
+        end
+      end
+
       def external_task=(external_task_data)
         #currently we assume everything coming from invoke_external_task_methods are tasks
         tasks = transform_task_response(external_task_data)

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

@@ -6,30 +6,25 @@ module Actions
         def plan(repository, smart_proxy, options = {})
           options[:contents_changed] = (options && options.key?(:contents_changed)) ? options[:contents_changed] : true
           sequence do
-            if !::Katello::RepositoryTypeManager.find(repository.content_type).pulp3_skip_publication
-              action_output = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id,
-                                 :options => options).output
-              plan_action(RefreshDistribution, repository, smart_proxy,
-                            :tasks => action_output,
-                            :use_repository_version => false,
-                            :contents_changed => options[:contents_changed])
-            else
-              plan_action(RefreshDistribution, repository, smart_proxy,
-                            :use_repository_version => true,
-                            :contents_changed => options[:contents_changed])
+            unless repository.repository_type.pulp3_skip_publication
+              plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id,
+                         :options => options).output
             end
+            plan_action(RefreshDistribution, repository, smart_proxy,
+                          :contents_changed => options[:contents_changed])
           end
         end
 
         def invoke_external_task
-          if input[:options][:sync_task_output] &&
-              ::Katello::Pulp3::Task.publication_href(input[:options][:sync_task_output]).present?
-            return input[:options][:sync_task_output]
-          end
-
           repository = ::Katello::Repository.find(input[:repository_id])
-          smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
-          output[:response] = repository.backend_service(smart_proxy).with_mirror_adapter.create_publication
+          #yum repositories use metadata mirroring always, so we should never
+          # regenerate metadata on proxies
+          if repository.yum?
+            []
+          else
+            smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
+            repository.backend_service(smart_proxy).with_mirror_adapter.create_publication
+          end
         end
       end
     end

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

@@ -13,18 +13,8 @@ module Actions
 
         def invoke_external_task
           smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
-          options = input[:options]
-          tasks = options[:tasks]
           repo = ::Katello::Repository.find(input[:repository_id])
-          if options[:use_repository_version]
-            repo.backend_service(smart_proxy).with_mirror_adapter.refresh_distributions(:use_repository_version => true)
-          elsif tasks && tasks[:pulp_tasks] && tasks[:pulp_tasks].first
-            if (publication_href = ::Katello::Pulp3::Task.publication_href(tasks[:pulp_tasks]))
-              repo.backend_service(smart_proxy).with_mirror_adapter.refresh_distributions(:publication => publication_href)
-            else
-              fail "Unable to refresh distribution for repo #{repository.id}, could not find a publication_href"
-            end
-          end
+          repo.backend_service(smart_proxy).with_mirror_adapter.refresh_distributions
         end
       end
     end

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

@@ -17,7 +17,7 @@ module Actions
         end
 
         def run
-          smart_proxy = ::SmartProxy.find(input[:smart_proxy_id])
+          smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
           api = ::Katello::Pulp3::Api::Core.new(smart_proxy)
           export_data = api.export_api.list(input[:exporter_data][:pulp_href]).results.first
           output[:exported_file_checksum] = export_data.output_file_info

data/app/lib/actions/pulp3/orchestration/repository/generate_metadata.rb

@@ -4,13 +4,15 @@ module Actions
       module Repository
         class GenerateMetadata < Pulp3::Abstract
           def plan(repository, smart_proxy, options = {})
+            force_publication = options.fetch(:force_publication, repository.publication_href.nil?)
+
             options[:contents_changed] = (options && options.key?(:contents_changed)) ? options[:contents_changed] : true
             publication_content_type = !::Katello::RepositoryTypeManager.find(repository.content_type).pulp3_skip_publication
 
             sequence do
               if options[:source_repository] && publication_content_type
                 plan_self(source_repository_id: options[:source_repository].id, target_repository_id: repository.id, smart_proxy_id: smart_proxy.id)
-              elsif publication_content_type
+              elsif publication_content_type && (force_publication || repository.publication_href.nil? || !repository.using_mirrored_metadata?)
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
               plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected

data/app/lib/actions/pulp3/orchestration/repository/import_upload.rb

@@ -4,58 +4,41 @@ module Actions
     module Orchestration
       module Repository
         class ImportUpload < Pulp3::Abstract
-          # rubocop:disable Metrics/AbcSize
           def plan(repository, smart_proxy, args)
             file = {:filename => args.dig(:unit_key, :name), :sha256 => args.dig(:unit_key, :checksum) }
             content_unit_href = args.dig(:unit_key, :content_unit_id)
             docker_tag = (args.dig(:unit_type_id) == "docker_tag")
-            sequence do
-              if content_unit_href
-                duplicate_sha_path_content_list = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, args.dig(:unit_type_id), file, file[:sha256])
-                duplicate_content_href = duplicate_sha_path_content_list&.results&.first&.pulp_href
 
-                if duplicate_content_href
-                  plan_self(:commit_output => [], :content_unit_href => duplicate_content_href)
-                  action_output = plan_action(Pulp3::Repository::ImportUpload, duplicate_content_href, repository, smart_proxy).output
-                  plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
-                else
-                  duplicate_sha_artifact_list = ::Katello::Pulp3::Api::Core.new(smart_proxy).artifacts_api.list("sha256": file[:sha256])
-                  duplicate_sha_artifact_href = duplicate_sha_artifact_list&.results&.first&.pulp_href
-                  if duplicate_sha_artifact_href
-                    artifact_output = plan_action(Pulp3::Repository::SaveArtifact,
-                                                         file, repository, smart_proxy,
-                                                         nil, args.dig(:unit_type_id),
-                                                         artifact_href: duplicate_sha_artifact_href).output
-                    content_unit_href = artifact_output[:pulp_tasks]
-                    plan_self(:commit_output => nil, :artifact_output => artifact_output[:pulp_tasks])
-                    action_output = plan_action(Pulp3::Repository::ImportUpload, content_unit_href, repository, smart_proxy).output
-                    plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
-                  end
-                end
-              elsif docker_tag
+            sequence do
+              if docker_tag
                 tag_manifest_output = plan_action(Pulp3::Repository::UploadTag,
-                            repository,
-                            smart_proxy,
-                            args).output
+                                                  repository,
+                                                  smart_proxy,
+                                                  args).output
                 plan_self(:commit_output => tag_manifest_output[:pulp_tasks])
                 plan_action(Pulp3::Repository::SaveVersion, repository, {force_fetch_version: true, tasks: tag_manifest_output[:pulp_tasks]})
               else
-                commit_output = plan_action(Pulp3::Repository::CommitUpload,
-                                            repository,
-                                            smart_proxy,
-                                            "/pulp/api/v3/uploads/" + args.dig(:upload_id) + "/",
-                                            args.dig(:unit_key, :checksum)).output
-
-                artifact_output = plan_action(Pulp3::Repository::SaveArtifact,
-                                              file,
+                if content_unit_href
+                  artifact_output = { :content_unit_href => content_unit_href }
+                  commit_output = {}
+                else
+                  commit_output = plan_action(Pulp3::Repository::CommitUpload,
                                               repository,
                                               smart_proxy,
-                                              commit_output[:pulp_tasks],
-                                              args.dig(:unit_type_id)).output
-                content_unit_href = artifact_output[:pulp_tasks]
-                plan_self(:commit_output => commit_output[:pulp_tasks], :artifact_output => artifact_output[:pulp_tasks])
-                action_output = plan_action(Pulp3::Repository::ImportUpload, content_unit_href, repository, smart_proxy).output
-                plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
+                                              "/pulp/api/v3/uploads/" + args.dig(:upload_id) + "/",
+                                              args.dig(:unit_key, :checksum)).output
+
+                  artifact_output = plan_action(Pulp3::Repository::SaveArtifact,
+                                                file,
+                                                repository,
+                                                smart_proxy,
+                                                commit_output[:pulp_tasks],
+                                                args.dig(:unit_type_id)).output
+                end
+
+                plan_self(:commit_output => commit_output[:pulp_tasks], :artifact_output => artifact_output)
+                import_output = plan_action(Pulp3::Repository::ImportUpload, artifact_output, repository, smart_proxy).output
+                plan_action(Pulp3::Repository::SaveVersion, repository, tasks: import_output[:pulp_tasks])
               end
             end
           end
@@ -65,7 +48,7 @@ module Actions
             if input[:content_unit_href]
               output[:content_unit_href] = input[:content_unit_href]
             elsif input[:artifact_output]
-              output[:content_unit_href] = input[:artifact_output].last[:created_resources].first
+              output[:content_unit_href] = input[:artifact_output][:content_unit_href] || input[:artifact_output][:pulp_tasks].last[:created_resources].first
             else
               output[:content_unit_href] = nil
             end

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

@@ -11,7 +11,14 @@ module Actions
 
               force_fetch_version = true if options[:optimize] == false
               version_output = plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks], :force_fetch_version => force_fetch_version).output
-              plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :contents_changed => version_output[:contents_changed], :skip_publication_creation => version_output[:publication_provided])
+
+              #force contents_changed to true if we're doing a 'force' sync
+              if options[:optimize] == false
+                contents_changed = true
+              else
+                contents_changed = version_output[:contents_changed]
+              end
+              plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :contents_changed => contents_changed, :skip_publication_creation => version_output[:publication_provided])
               plan_self(:subaction_output => version_output)
             end
           end

data/app/lib/actions/pulp3/orchestration/repository/upload_content.rb

@@ -19,10 +19,10 @@ module Actions
                   upload_action_output = plan_action(Pulp3::Repository::UploadFile, repository, smart_proxy, file[:path]).output
                   artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, upload_action_output[:pulp_tasks], unit_type_id).output
                 end
-                content_href = artifact_action_output[:pulp_tasks]
+
               end
-              content_href ||= duplicate_content_href
-              action_output = plan_action(Pulp3::Repository::ImportUpload, content_href, repository, smart_proxy).output
+              artifact_action_output ||= {:content_unit_href => duplicate_content_href}
+              action_output = plan_action(Pulp3::Repository::ImportUpload, artifact_action_output, repository, smart_proxy).output
               plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
               plan_self(:subaction_output => action_output)
             end

data/app/lib/actions/pulp3/repository/commit_upload.rb

@@ -13,7 +13,7 @@ module Actions
           duplicate_sha_artifact_list = ::Katello::Pulp3::Api::Core.new(smart_proxy).artifacts_api.list("sha256": input[:sha256])
           duplicate_sha_artifact_href = duplicate_sha_artifact_list&.results&.first&.pulp_href
           if duplicate_sha_artifact_href
-            uploads_api.delete(upload_href)
+            uploads_api.delete(input[:upload_href])
             output[:artifact_href] = duplicate_sha_artifact_href
             output[:pulp_tasks] = nil
           else