katello 4.3.0.rc1 → 4.3.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf975eaf437422cc7622770087b3b996c0834bb4d0077de55ed4748670c888d2
-  data.tar.gz: a6fbabac90eeed02b2b4a404e1c2d8af1cb245c083daf5981e2471ca035157b5
+  metadata.gz: 83de032a01e5d20e480d164eb425db853b1eea9a4668eb1aa853bfaa5d6a703a
+  data.tar.gz: aad3b14f2608df9c71cb039222ced8baf98bc89537c28967fcc1d47ac3ce3c5c
 SHA512:
-  metadata.gz: d349265901e8142d15ad6ee35fcf6045bec5cbc8197799b9f8b8fac3edbdb29433a40f774345118a86a598587b5656e04aa9f20263cdb81ed388c9f373414a55
-  data.tar.gz: ee28f705628e3ff302918e2bf30ba5a78addc92454937fe43fc34ed2f48b4388f1f1294c630899884afb0d6071bc9ec733843b52175c1af5ef90160759d0f814
+  metadata.gz: cb93e596697f4639b7b4ba3d512524f9880f63442bdba0b4963f73fe6aa18b61d4565f71f488a7cd99f54c0908cbe74cc59468b987450c5d02c9f8020a521761
+  data.tar.gz: 9ffa356f5005ab1e2119c119c24837530c23d4d004c1a9c99a3b120fc648f443bf126faae8adff3a5763714ba70d9aa412976f50b6d886e6dc3bd0fb4257dcce

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

@@ -134,6 +134,10 @@ module Katello
       scoped_search_results(query: blank_query, page: page, per_page: per_page, error: message)
     end
 
+    def skip_session
+      request.session_options[:skip] = true
+    end
+
     protected
 
     def scoped_search_query(query, group)

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

@@ -4,7 +4,7 @@ module Katello
       api_base_url "/katello/api"
     end
 
-    before_action :find_capsule, :except => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment]
+    before_action :find_capsule, :except => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment, :reclaim_space]
     before_action :find_editable_capsule, :only => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment]
     before_action :find_environment, :only => [:add_lifecycle_environment, :remove_lifecycle_environment]
     before_action :find_optional_organization, :only => [:sync_status]
@@ -86,6 +86,14 @@ module Katello
       end
     end
 
+    api :POST, '/capsules/:id/reclaim_space', N_('Reclaim space from all On Demand repositories on a smart proxy')
+    param :id, :number, :required => true, :desc => N_('Id of the smart proxy')
+    def reclaim_space
+      find_capsule(true)
+      task = async_task(::Actions::Pulp3::CapsuleContent::ReclaimSpace, @capsule)
+      respond_for_async :resource => task
+    end
+
     protected
 
     def respond_for_lifecycle_environments_index(environments)
@@ -104,9 +112,9 @@ module Katello
       end
     end
 
-    def find_capsule
+    def find_capsule(primary_okay = false)
       @capsule = SmartProxy.unscoped.authorized(:view_capsule_content).find(params[:id])
-      unless @capsule&.pulp_mirror?
+      unless @capsule&.pulp_mirror? || primary_okay
         fail _("This request may only be performed on a Smart proxy that has the Pulpcore feature with mirror=true.")
       end
     end

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

@@ -10,7 +10,7 @@ module Katello
     param :repository_id, :number, :required => true, :desc => N_("repository id")
     param :size, :number, :required => true, :desc => N_("Size of file to upload")
     param :checksum, String, :required => false, :desc => N_("Checksum of file to upload")
-    param :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'rpm', 'srpm')")
+    param :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree_ref', 'rpm', 'srpm')")
     def create
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Ansible collections.") if @repository.ansible_collection?
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type)&.default_managed_content_type&.label

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

@@ -1,10 +1,15 @@
 module Katello
   class Api::V2::GenericContentUnitsController < Api::V2::ApiController
+    resource_description do
+      name 'Content Units'
+      param :content_type, String, desc: N_("Possible values: #{Katello::RepositoryTypeManager.generic_content_types.join(", ")}"), required: true
+    end
+    apipie_concern_subst(:a_resource => N_("a content unit"), :resource_id => "content_units")
+
     Katello::RepositoryTypeManager.generic_content_types(false).each do |type|
-      apipie_concern_subst(:a_resource => N_(type), :resource_id => type.pluralize)
-      resource_description do
-        name type.pluralize.titleize
-      end
+      api :GET, "/#{type.pluralize}", N_("List %s" % type.pluralize)
+      api :GET, "/#{type.pluralize}/:id", N_("Show %s" % type.gsub(/_/, ' '))
+      api :GET, "/repositories/:repository_id/#{type.pluralize}/:id", N_("Show %s" % type.gsub(/_/, ' '))
     end
 
     include Katello::Concerns::Api::V2::RepositoryContentController
@@ -14,6 +19,7 @@ module Katello
     end
 
     def resource_class
+      fail "Required param content_type is missing" unless params[:content_type]
       ::Katello::GenericContentUnit.where(content_type: params[:content_type].singularize)
     end
 

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

@@ -63,6 +63,7 @@ module Katello
     param :errata_ids, Array, :desc => N_("List of Errata ids to install. Will be removed in %s") % katello_agent_removal_release, required: true
 
     param_group :bulk_errata_ids
+    param_group :search, Api::V2::ApiController
     def apply
       task = async_task(::Actions::Katello::Host::Erratum::Install, @host, content: @errata_ids)
       respond_for_async :resource => task
@@ -143,7 +144,11 @@ module Katello
         missing = params[:errata_ids] - Erratum.where(:errata_id => params[:errata_ids]).pluck(:errata_id)
         fail HttpErrors::NotFound, _("Couldn't find errata ids '%s'") % missing.to_sentence if missing.any?
         @errata_ids = params[:errata_ids]
+      elsif params[:search]
+        @errata_ids = @host.advisory_ids(search: params[:search])
       else
+        # old angular way
+        # Todo: remove this when the old content-host errata page is removed
         @errata_ids = find_bulk_errata_ids([@host], params[:bulk_errata_ids])
       end
     end

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

@@ -20,10 +20,12 @@ module Katello
 
     api :GET, "/hosts/:host_id/packages", N_("List packages installed on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
+    param :include_latest_upgradable, :boolean, :desc => N_("Also include the latest upgradable package version for each host package")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::InstalledPackage)
     def index
       collection = scoped_search(index_relation, :name, :asc, :resource_class => ::Katello::InstalledPackage)
+      collection[:results] = HostPackagePresenter.with_latest(collection[:results], @host) if ::Foreman::Cast.to_bool(params[:include_latest_upgradable])
       respond_for_index(:collection => collection)
     end
 

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

@@ -35,6 +35,10 @@ module Katello
       @host.host_traces
     end
 
+    def total_selectable(query)
+      query.where(:id => @host.host_traces.selectable).count
+    end
+
     private
 
     def find_host

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

@@ -50,6 +50,14 @@ module Katello
       end
     end
 
+    api :POST, "/repositories/bulk/reclaim_space", N_("Reclaim space from On Demand repositories")
+    param :ids, Array, :desc => N_("List of repository ids"), :required => true
+    def reclaim_space_from_repositories
+      task = async_task(::Actions::Pulp3::Repository::ReclaimSpace, @repositories)
+
+      respond_for_async :resource => task
+    end
+
     private
 
     def find_repositories

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

@@ -23,7 +23,7 @@ module Katello
     before_action :find_unauthorized_katello_resource, :only => [:gpg_key_content]
     before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy, :sync,
                                                                :remove_content, :upload_content, :republish,
-                                                               :import_uploads, :verify_checksum]
+                                                               :import_uploads, :verify_checksum, :reclaim_space]
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
     before_action :error_on_rh_product, :only => [:create]
@@ -234,6 +234,10 @@ module Katello
         fail HttpErrors::UnprocessableEntity, msg
       end
 
+      if !repo_params[:url].nil? && URI(repo_params[:url]).userinfo
+        fail "Do not include the username/password in the URL. Use the username/password settings instead."
+      end
+
       gpg_key = get_content_credential(repo_params, CONTENT_CREDENTIAL_GPG_KEY_TYPE)
       ssl_ca_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE)
       ssl_client_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE)
@@ -317,6 +321,15 @@ module Katello
       raise HttpErrors::BadRequest, e.message
     end
 
+    api :POST, "/repositories/:id/reclaim_space", N_("Reclaim space from an On Demand repository")
+    param :id, :number, :required => true, :desc => N_("repository ID")
+    def reclaim_space
+      task = async_task(::Actions::Pulp3::Repository::ReclaimSpace, @repository)
+      respond_for_async :resource => task
+    rescue Errors::InvalidActionOptionError => e
+      raise HttpErrors::BadRequest, e.message
+    end
+
     api :PUT, "/repositories/:id", N_("Update a repository")
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :name, String, :required => false
@@ -324,6 +337,9 @@ module Katello
     param_group :repo
     def update
       repo_params = repository_params
+      if !repo_params[:url].nil? && URI(repo_params[:url]).userinfo
+        fail "Do not include the username/password in the URL. Use the username/password settings instead."
+      end
 
       if @repository.generic?
         generic_remote_options = generic_remote_options_hash(repo_params)
@@ -421,10 +437,16 @@ module Katello
       end
 
       begin
+        upload_args = {
+          content_type: params[:content_type],
+          generate_metadata: generate_metadata,
+          sync_capsule: sync_capsule
+        }
+        upload_args.merge!(generic_content_type_import_upload_args)
+
         respond_for_async(resource: send(
           async ? :async_task : :sync_task,
-          ::Actions::Katello::Repository::ImportUpload, @repository, uploads,
-          generate_metadata: generate_metadata, sync_capsule: sync_capsule, content_type: params[:content_type]))
+          ::Actions::Katello::Repository::ImportUpload, @repository, uploads, upload_args))
       rescue => e
         raise HttpErrors::BadRequest, e.message
       end
@@ -617,6 +639,16 @@ module Katello
       generic_remote_options
     end
 
+    def generic_content_type_import_upload_args
+      args = {}
+      @repository.repository_type&.import_attributes&.collect do |import_attribute|
+        if params[import_attribute.api_param]
+          args[import_attribute.api_param] = params[import_attribute.api_param]
+        end
+      end
+      args
+    end
+
     def check_import_parameters
       @repository.repository_type&.import_attributes&.each do |import_attribute|
         if import_attribute.required && params[import_attribute.api_param].blank?

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

@@ -28,8 +28,8 @@ module Katello
     param :with_custom, :bool, :required => false, :desc => N_("If true, return custom repository sets along with redhat repos")
     param :activation_key_id, :number, :desc => N_("activation key identifier"), :required => false
     param :host_id, :number, :desc => N_("Id of the host"), :required => false
-    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions. Relevant for Activation Keys only")
-    param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the activation key's content view version. Relevant for Activation Keys only")
+    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions.")
+    param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the host's or activation key's content view version and lifecycle environment.")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::ProductContent)
     def index

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

@@ -1,35 +1,28 @@
 module Katello
   class Api::V2::RootController < Api::V2::ApiController
     skip_before_action :authorize # ok - only shows URLs available
+    skip_before_action :load_settings # no Settings used here, avoid DB calls
+    after_action :skip_session
 
     resource_description do
       api_version 'v2'
       api_base_url "/katello/api"
     end
 
-    def resource_list
-      all_routes = Engine.routes.routes
-      all_routes = all_routes.collect { |r| r.path.spec.to_s }
-
-      api_root_routes = all_routes.select do |path|
-        path =~ %r{^/katello/api(\(/:api_version\))?/[^/]+/:id\(\.:format\)$}
-      end
-      api_root_routes = api_root_routes.collect do |path|
-        path = path.sub("(/:api_version)", "")
-        path[0..-(":id(.:format)".length + 1)]
-      end
-
-      api_root_routes.collect! { |r| { :rel => r["/katello/api/".size..-2], :href => r } }
-
-      respond_for_index :collection => api_root_routes
-    end
-
     def rhsm_resource_list
       # The RHSM resource list is required to interact with RHSM on the client.
       # When requested, it will return a list of the resources (href & rel) defined by katello
       # for the /rhsm namespace.  The rel values are used by RHSM to determine if the server
       # supports a particular resource (e.g. environments, guestids, organizations..etc)
 
+      render json: self.class.rhsm_resource_list
+    end
+
+    def self.rhsm_resource_list
+      @rhsm_resource_list ||= generate_rhsm_resource_list
+    end
+
+    def self.generate_rhsm_resource_list
       all_routes = Engine.routes.routes.collect { |r| r.path.spec.to_s }
 
       api_routes = all_routes.select do |path|
@@ -53,8 +46,6 @@ module Katello
 
       api_routes.uniq!
       api_routes.collect! { |r| { :rel => r.split('/').last, :href => r } }
-
-      respond_for_index :collection => api_routes, :template => 'resource_list'
     end
   end
 end

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

@@ -8,7 +8,6 @@ module Katello
           bulk_params = ActiveSupport::JSON.decode(bulk_params).
                         deep_symbolize_keys
         end
-
         bulk_params[:included] ||= {}
         bulk_params[:excluded] ||= {}
 
@@ -22,18 +21,9 @@ module Katello
           fail HttpErrors::BadRequest, _("Sending a list of included IDs is not allowed when all items are being selected.")
         end
 
-        items = model_scope
-        if bulk_params[:included][:ids]
-          items = model_scope.where(key => bulk_params[:included][:ids])
-        elsif bulk_params[:included][:search]
-          items = model_scope.search_for(bulk_params[:included][:search])
-        end
-
-        if bulk_params[:excluded][:ids]
-          items = items.where.not(key => bulk_params[:excluded][:ids])
-        end
-
-        items
+        ::Katello::BulkItemsHelper.new(bulk_params: bulk_params,
+                                       model_scope: model_scope,
+                                       key: key).fetch
       end
     end
   end

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

@@ -28,7 +28,7 @@ module Katello
       end
 
       def context_urls
-        super.merge(rhsm_url: rhsm_url, pulp_content_url: pulp_content_url)
+        super.merge(rhsm_url: smart_proxy.rhsm_url, pulp_content_url: smart_proxy.pulp_content_url)
       end
 
       private
@@ -43,14 +43,6 @@ module Katello
           proxy
         end
       end
-
-      def rhsm_url
-        URI(smart_proxy.rhsm_url)
-      end
-
-      def pulp_content_url
-        smart_proxy.setting(SmartProxy::PULP3_FEATURE, 'content_app_url')
-      end
     end
   end
 end

data/app/controllers/katello/remote_execution_controller.rb

@@ -48,7 +48,7 @@ module Katello
 
       def inputs
         if feature_name == 'katello_errata_install'
-          { :errata => errata_inputs }
+          { "Errata Search Query" => "errata_id ^ (#{errata_inputs.join(',')})" }
         elsif feature_name == 'katello_service_restart'
           { :helper => params[:name] }
         elsif feature_name == 'katello_module_stream_action'

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

@@ -40,7 +40,7 @@ module Actions
             pulp_repo = repo.backend_service(smart_proxy)
             if !current_repos_on_capsule_ids.include?(repo.id)
               pulp_repo.create_mirror_entities
-            elsif pulp_repo.mirror_needs_updates?
+            else
               tasks += pulp_repo.refresh_mirror_entities
             end
           end

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

@@ -3,6 +3,7 @@ module Actions
     module CapsuleContent
       class SyncCapsule < ::Actions::EntryAction
         include Actions::Katello::PulpSelector
+        # rubocop:disable Metrics/MethodLength
         def plan(smart_proxy, options = {})
           plan_self(:smart_proxy_id => smart_proxy.id)
           action_subject(smart_proxy)
@@ -17,11 +18,11 @@ module Actions
             repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
                 repo_batch.each do |repo|
-                  plan_pulp_action(
-                    [Actions::Pulp::Orchestration::Repository::SmartProxySync,
-                     Actions::Pulp3::CapsuleContent::Sync],
-                                     repo, smart_proxy,
-                                     skip_metadata_check: skip_metadata_check)
+                  if smart_proxy.backend_service_type(repo) == Actions::Pulp3::Abstract::BACKEND_SERVICE_TYPE
+                    plan_action(Actions::Pulp3::CapsuleContent::Sync,
+                      repo, smart_proxy,
+                      skip_metadata_check: skip_metadata_check)
+                  end
                 end
               end
 
@@ -39,6 +40,7 @@ module Actions
             end
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def repos_to_sync(smart_proxy, environment, content_view, repository, skip_metatadata_check = false)
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)

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

@@ -37,7 +37,7 @@ module Actions
               handle_redhat_content(repository) unless skip_environment_update
             else
               if destroy_content && !skip_environment_update
-                handle_custom_content(repository)
+                handle_custom_content(repository, remove_from_content_view_versions)
               end
             end
           end
@@ -57,9 +57,9 @@ module Actions
           end
         end
 
-        def handle_custom_content(repository)
+        def handle_custom_content(repository, remove_from_content_view_versions)
           #if this is the last instance of a custom repo, destroy the content
-          if repository.root.repositories.where.not(id: repository.id).empty?
+          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty?
             plan_action(::Actions::Katello::Product::ContentDestroy, repository.root)
           end
         end

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

@@ -4,6 +4,7 @@ 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
@@ -21,6 +22,7 @@ module Actions
           else
             unit_type_id = SmartProxy.pulp_primary.content_service(options[:content_type])::CONTENT_TYPE
           end
+          content_type = ::Katello::RepositoryTypeManager.find_content_type(options[:content_type])
 
           sequence do
             upload_results = concurrence do
@@ -34,8 +36,15 @@ module Actions
                   unit_metadata: unit_metadata
                 }
 
-                import_upload = plan_action(Actions::Pulp3::Orchestration::Repository::ImportUpload,
-                                  repository, SmartProxy.pulp_primary, import_upload_args)
+                import_upload_args.merge!(options)
+
+                if content_type.repository_import_on_upload
+                  action_class = ::Actions::Pulp3::Orchestration::Repository::ImportRepositoryUpload
+                else
+                  action_class = ::Actions::Pulp3::Orchestration::Repository::ImportUpload
+                end
+
+                import_upload = plan_action(action_class, 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
@@ -46,6 +55,7 @@ module Actions
             plan_self(repository_id: repository.id, sync_capsule: sync_capsule, upload_results: upload_results)
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])

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

@@ -77,8 +77,6 @@ module Actions
             Presenters::FileUnitPresenter.new(self)
           elsif repo.try(:docker?)
             Presenters::DockerPresenter.new(self)
-          elsif repo.try(:ostree?)
-            Presenters::OstreePresenter.new(self)
           elsif repo.try(:deb?)
             Presenters::DebPresenter.new(self)
           end

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

@@ -46,7 +46,7 @@ module Actions
       end
 
       def combined_tasks
-        return nil if pulp_tasks.nil? || task_groups.nil?
+        return nil if pulp_tasks.nil? && task_groups.nil?
         pulp_tasks + task_groups
       end
 
@@ -120,11 +120,23 @@ module Actions
       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)
-        output[:pulp_tasks] = new_or_existing_objects(::Katello::Pulp3::Task, tasks)
+        output[:pulp_tasks] = [] if output[:pulp_tasks].nil?
+        output[:task_groups] = [] if output[:task_groups].nil?
+        if tasks.detect { |task| task['task'] || (task['pulp_href'] && !task['tasks']) }
+          output[:pulp_tasks] = new_or_existing_objects(::Katello::Pulp3::Task, tasks)
+          add_task_groups
+        else
+          output[:pulp_tasks] = []
+          tasks.each do |task|
+            if task['task_group']
+              output[:task_groups] << ::Katello::Pulp3::TaskGroup.new_from_href(smart_proxy, task['task_group'])
+            elsif task['pulp_href'] && task['tasks']
+              output[:task_groups] << ::Katello::Pulp3::TaskGroup.new_from_href(smart_proxy, task['pulp_href'])
+            end
+          end
+        end
 
-        add_task_groups
         check_for_errors
       end
 

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

@@ -17,13 +17,14 @@ module Actions
 
         def invoke_external_task
           repository = ::Katello::Repository.find(input[:repository_id])
+          backend = repository.backend_service(smart_proxy).with_mirror_adapter
           #yum repositories use metadata mirroring always, so we should never
-          # regenerate metadata on proxies
-          if repository.yum?
+          # regenerate metadata on proxies.  but if there is no publication,
+          # it means the repo was likely empty and syncing didn't generate one
+          if repository.yum? && backend.publication_href.present?
             []
           else
-            smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
-            repository.backend_service(smart_proxy).with_mirror_adapter.create_publication
+            backend.create_publication
           end
         end
       end

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

@@ -0,0 +1,25 @@
+module Actions
+  module Pulp3
+    module CapsuleContent
+      class ReclaimSpace < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy)
+          if smart_proxy.pulp_primary?
+            repository_hrefs = ::Katello::Pulp3::RepositoryReference.default_cv_repository_hrefs(::Katello::Repository.unscoped.on_demand, ::Organization.all)
+            repository_hrefs.flatten!
+          else
+            if smart_proxy.download_policy != ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
+              fail _('Only On Demand smart proxies may have space reclaimed.')
+            end
+            repository_hrefs = ::Katello::Pulp3::Api::Core.new(smart_proxy).core_repositories_list_all(fields: 'pulp_href').map(&:pulp_href)
+          end
+          plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
+        end
+
+        def invoke_external_task
+          output[:pulp_tasks] = ::Katello::Pulp3::Api::Core.new(SmartProxy.find(input[:smart_proxy_id])).
+            repositories_reclaim_space_api.reclaim(repo_hrefs: input[:repository_hrefs])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module Repository
+        #Used for a different type of uploading where you are importing an entire repository, not a single content unit
+        # This workflow involves never actually creating a content unit directly, but instead importing the artifact directly into the repository
+        class ImportRepositoryUpload < Pulp3::Abstract
+          def plan(repository, smart_proxy, args)
+            file = {:filename => args.dig(:unit_key, :name), :sha256 => args.dig(:unit_key, :checksum) }
+            sequence do
+              upload_href = "/pulp/api/v3/uploads/#{args.dig(:upload_id)}/" if args.dig(:upload_id) && args.dig(:upload_id) != 'duplicate'
+              commit_output = plan_action(Pulp3::Repository::CommitUpload,
+                                          repository,
+                                          smart_proxy,
+                                          upload_href,
+                                          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), args).output
+              plan_self(:artifact_output => artifact_output)
+              plan_action(Pulp3::Repository::SaveVersion, repository, tasks: artifact_output[:pulp_tasks])
+            end
+          end
+
+          def run
+            output[:content_unit_href] = input[:artifact_output][:content_unit_href] || input[:artifact_output][:pulp_tasks].last[:created_resources].first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,7 @@ module Actions
                                                 repository,
                                                 smart_proxy,
                                                 commit_output[:pulp_tasks],
-                                                args.dig(:unit_type_id)).output
+                                                args.dig(:unit_type_id), args).output
                 end
 
                 plan_self(:commit_output => commit_output[:pulp_tasks], :artifact_output => artifact_output)

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

@@ -1,6 +1,7 @@
 module Actions
   module Pulp3
     module Repository
+      #Creates an artifacts
       class CommitUpload < Pulp3::AbstractAsyncTask
         def plan(repository, smart_proxy, upload_href, sha256)
           plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :upload_href => upload_href, :sha256 => sha256)
@@ -10,10 +11,11 @@ module Actions
           repo = ::Katello::Repository.find(input[:repository_id])
           repo_backend_service = repo.backend_service(smart_proxy)
           uploads_api = repo_backend_service.core_api.uploads_api
+
           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(input[:upload_href])
+            uploads_api.delete(input[:upload_href]) if input[:upload_href]
             output[:artifact_href] = duplicate_sha_artifact_href
             output[:pulp_tasks] = nil
           else