katello 3.3.2 → 3.4.0.rc1

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

@@ -12,6 +12,7 @@ module Actions
 
           if update_content?(repository)
             plan_action(::Actions::Candlepin::Product::ContentUpdate,
+                        :owner => repository.organization.label,
                         :content_id => repository.content_id,
                         :name => repository.content.name,
                         :content_url => ::Katello::Glue::Pulp::Repos.custom_content_path(repository.product, repository.label),

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

@@ -0,0 +1,34 @@
+module Actions
+  module Katello
+    module Repository
+      class UploadPackageGroup < Actions::EntryAction
+        def plan(repository, params)
+          action_subject(repository)
+          unit_key = {"repo_id": repository.pulp_id, "id": params[:name].parameterize.underscore}
+          params = params.slice(:name, :description, :user_visible, :mandatory_package_names, :optional_package_names, :conditional_package_names, :default_package_names)
+
+          sequence do
+            upload_request = plan_action(Pulp::Repository::CreateUploadRequest)
+            pkg_group_upload = plan_action(Pulp::Repository::ImportUpload,
+                                           pulp_id: repository.pulp_id,
+                                           unit_type_id: 'package_group',
+                                           unit_key: unit_key,
+                                           upload_id: upload_request.output[:upload_id],
+                                           unit_metadata: params)
+
+            plan_action(IndexPackageGroups, repository)
+            plan_action(FinishUpload, repository, :dependency => pkg_group_upload.output, :generate_metadata => true)
+          end
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
+        def humanized_name
+          _("Create Package Group")
+        end
+      end
+    end
+  end
+end

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

@@ -34,8 +34,8 @@ module Actions
           else
             substitutor = cdn_var_substitutor
             return [] unless substitutor
-            substitutor.substitute_vars(content.contentUrl).map do |(substitutions, path)|
-              prepare_result(substitutions, path)
+            substitutor.substitute_vars(content.contentUrl).map do |path_with_substitutions|
+              prepare_result(path_with_substitutions.substitutions, path_with_substitutions.path)
             end
           end
         end
@@ -59,7 +59,6 @@ module Actions
               substitutions: {},
               path:          mapper.feed_url,
               repo_name:     mapper.name,
-              pulp_id:       mapper.pulp_id,
               registry_name: registry["name"],
               enabled:       !repo.nil?,
               promoted:      (!repo.nil? && repo.promoted?)
@@ -74,7 +73,6 @@ module Actions
             path:          mapper.path,
             repo_name:     mapper.name,
             name:          mapper.content.name,
-            pulp_id:       mapper.pulp_id,
             enabled:       !repo.nil?,
             promoted:      (!repo.nil? && repo.promoted?)
           }

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

@@ -0,0 +1,24 @@
+module Actions
+  module Middleware
+    class SkipIfMatchingContent < Dynflow::Middleware
+      def run(*args)
+        pass(*args) if execute?
+      end
+
+      def finalize(*args)
+        pass(*args) if execute?
+      end
+
+      private
+
+      def execute?
+        if action.input.keys.include?('matching_content') && action.input['matching_content']
+          self.action.output[:matching_content_skip] = true
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp/abstract.rb

@@ -7,7 +7,7 @@ module Actions
       def pulp_resources(capsule_id = nil)
         capsule_id ||= input["capsule_id"]
         if capsule_id
-          capsule_content = ::Katello::CapsuleContent.new(SmartProxy.find(capsule_id))
+          capsule_content = ::Katello::CapsuleContent.new(SmartProxy.unscoped.find(capsule_id))
           capsule_content.pulp_server.resources
         else
           ::Katello.pulp_server.resources
@@ -17,7 +17,7 @@ module Actions
       def pulp_extensions(capsule_id = nil)
         capsule_id ||= input["capsule_id"]
         if capsule_id
-          capsule_content = ::Katello::CapsuleContent.new(SmartProxy.find(capsule_id))
+          capsule_content = ::Katello::CapsuleContent.new(SmartProxy.unscoped.find(capsule_id))
           capsule_content.pulp_server.extensions
         else
           ::Katello.pulp_server.extensions

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

@@ -7,7 +7,11 @@ module Actions
         end
 
         def invoke_external_task
-          pulp_extensions.consumer.regenerate_applicability_by_ids(input[:uuids])
+          if input[:uuids].length == 1
+            pulp_resources.consumer.regenerate_applicability_by_id(input[:uuids].first)
+          else
+            pulp_extensions.consumer.regenerate_applicability_by_ids(input[:uuids])
+          end
         end
       end
     end

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

@@ -14,6 +14,16 @@ module Actions
         def invoke_external_task
           pulp_resources.repository.sync(input[:repo_pulp_id])
         end
+
+        def run_progress
+          # override this method so this task's progress isn't 0.5
+          # when it is initiated, skewing the progress bar progress
+          self.done? ? 1 : 0.1
+        end
+
+        def run_progress_weight
+          100
+        end
       end
     end
   end

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

@@ -7,9 +7,11 @@ module Actions
         end
 
         def run
-          puppet_env = ::Katello::ContentViewPuppetEnvironment.find(input[:id])
-          puppet_module_ids = pulp_extensions.repository.puppet_module_ids(puppet_env.pulp_id)
-          puppet_env.index_content(puppet_module_ids)
+          User.as_anonymous_admin do
+            puppet_env = ::Katello::ContentViewPuppetEnvironment.find(input[:id])
+            puppet_module_ids = pulp_extensions.repository.puppet_module_ids(puppet_env.pulp_id)
+            puppet_env.index_content(puppet_module_ids)
+          end
         end
       end
     end

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

@@ -5,6 +5,10 @@ module Actions
         def content_extension
           pulp_extensions.errata
         end
+
+        def criteria
+          super.merge(fields: ::Katello::Pulp::Erratum::PULP_SELECT_FIELDS)
+        end
       end
     end
   end

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

@@ -23,6 +23,8 @@ module Actions
           param :ssl_validation
           param :upstream_username
           param :upstream_password
+          param :ostree_upstream_sync_depth
+          param :ostree_publish_depth
         end
 
         def run
@@ -77,6 +79,7 @@ module Actions
           importer.ssl_client_cert = input[:ssl_client_cert]
           importer.ssl_client_key  = input[:ssl_client_key]
           importer.ssl_validation  = input[:ssl_validation]
+          importer.depth           = input[:ostree_upstream_sync_depth]
           importer.basic_auth_username = input[:upstream_username] if input[:upstream_username].present?
           importer.basic_auth_password = input[:upstream_password] if input[:upstream_password].present?
           importer
@@ -165,7 +168,8 @@ module Actions
         def docker_distributor
           options = { protected: !input[:unprotected] || false,
                       id: input[:pulp_id],
-                      auto_publish: true }
+                      auto_publish: true,
+                      repo_registry_id: input[:repo_registry_id]}
           Runcible::Models::DockerDistributor.new(options)
         end
 
@@ -179,6 +183,7 @@ module Actions
           options = { id: input[:pulp_id],
                       relative_path: input[:path],
                       auto_publish: true }
+          options[:depth] = input[:ostree_publish_depth] if input[:ostree_publish_depth]
           Runcible::Models::OstreeDistributor.new(options)
         end
       end

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

@@ -2,12 +2,15 @@ module Actions
   module Pulp
     module Repository
       class DistributorPublish < Pulp::AbstractAsyncTask
+        middleware.use Actions::Middleware::SkipIfMatchingContent
+
         input_format do
           param :pulp_id
           param :distributor_type_id
           param :source_pulp_id
           param :dependency
           param :override_config
+          param :matching_content
         end
 
         def invoke_external_task

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

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp
+    module Repository
+      class Download < Pulp::AbstractAsyncTask
+        input_format do
+          param :pulp_id
+          param :options
+        end
+
+        def invoke_external_task
+          output[:pulp_tasks] = pulp_resources.repository.download(input[:pulp_id], input[:options])
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,7 @@ module Actions
           param :unit_type_id
           param :upload_id
           param :unit_key
+          param :unit_metadata
         end
 
         def invoke_external_task
@@ -14,7 +15,7 @@ module Actions
                                                    input[:unit_type_id],
                                                    input[:upload_id],
                                                    input[:unit_key],
-                                                    unit_metadata: {})
+                                                   unit_metadata: input[:unit_metadata] || {})
         end
       end
     end

data/app/lib/actions/pulp/repository/presenters/ostree_presenter.rb

@@ -7,14 +7,27 @@ module Actions
             return 0.01 unless task_progress_details
 
             completion = 0.0
-            completion += 0.4 if content_completed?(details("import_create_repository"))
-            completion += 0.3 if content_completed?(details("import_pull"))
+            completion += 0.2 if content_completed?(details("import_create_repository"))
+
+            if content_completed?(details("import_pull"))
+              completion += 0.5
+            end
             completion += 0.3 if content_completed?(details("import_add_unit"))
             completion
           end
 
           private
 
+          def fetch_pull_ratio(content_details)
+            # looks like "details": "fetching 24980/46836 53%",
+            fetch_details_line = content_details["details"]
+            ret = "0"
+            if fetch_details_line[-1] == "%"
+              ret = fetch_details_line.split[-2] # "24980/46836"
+            end
+            ret
+          end
+
           def humanized_details
             ret = []
             ret << _("Cancelled") if cancelled?
@@ -24,7 +37,7 @@ module Actions
                      when "import_create_repository"
                        _("Creating local repository")
                      when "import_pull"
-                       _("Pulling remote branches")
+                       _("Pulling remote branches. Downloaded %s units." % fetch_pull_ratio(details("import_pull")))
                      when "import_add_unit"
                        _("Adding content units")
                      end

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

@@ -5,6 +5,10 @@ module Actions
         def content_extension
           pulp_extensions.errata
         end
+
+        def criteria
+          super.merge(fields: { :unit => ::Katello::Pulp::Erratum::PULP_SELECT_FIELDS})
+        end
       end
     end
   end

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

@@ -8,6 +8,7 @@ module Actions
           param :pulp_id
           param :task_id # In case we need just pair this action with existing sync task
           param :source_url # allow overriding the feed URL
+          param :options # Pulp sync options
         end
 
         def invoke_external_task
@@ -27,11 +28,10 @@ module Actions
             end
 
             sync_options[:feed] = input[:source_url] if input[:source_url]
-
-            sync_options[:remove_missing] = input[:remove_missing] if input.key? :remove_missing
-
             sync_options[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
 
+            sync_options.merge(input[:options]) if input[:options]
+
             output[:pulp_tasks] = pulp_tasks =
                 [pulp_resources.repository.sync(input[:pulp_id], override_config: sync_options)]
 

data/app/lib/katello/errors.rb

@@ -1,5 +1,7 @@
 module Katello
   module Errors
+    class InvalidActionOptionError < StandardError; end
+
     class InvalidRepositoryContent < StandardError; end
 
     class InvalidPuppetModuleError < InvalidRepositoryContent; end

data/app/lib/katello/repo_discovery.rb

@@ -2,10 +2,11 @@ module Katello
   class RepoDiscovery
     attr_reader :found, :crawled, :to_follow
 
-    def initialize(url, proxy = {}, crawled = [], found = [], to_follow = [])
-      #add a / on the end, as directories require it or else
-      #  They will get double slahes on them
+    def initialize(url, content_type = 'yum', upstream_username = nil, upstream_password = nil, proxy = {}, crawled = [], found = [], to_follow = [])
       @uri = uri(url)
+      @content_type = content_type
+      @upstream_username = upstream_username.empty? ? nil : upstream_username
+      @upstream_password = upstream_password.empty? ? nil : upstream_password
       @found = found
       @crawled = crawled
       @to_follow = to_follow
@@ -13,22 +14,46 @@ module Katello
     end
 
     def uri(url)
+      #add a / on the end, as directories require it or else
+      #  They will get double slahes on them
       url += '/' unless url.ends_with?('/')
       URI(url)
     end
 
     def run(resume_point)
-      if @uri.scheme == 'file'
-        file_crawl(uri(resume_point))
-      elsif %w(http https).include?(@uri.scheme)
-        http_crawl(uri(resume_point))
+      if @content_type == 'docker'
+        docker_search
       else
-        fail _("Unsupported URL protocol %s.") % @uri.scheme
+        if @uri.scheme == 'file'
+          file_crawl(uri(resume_point))
+        elsif %w(http https).include?(@uri.scheme)
+          http_crawl(uri(resume_point))
+        else
+          fail _("Unsupported URL protocol %s.") % @uri.scheme
+        end
       end
     end
 
     private
 
+    def docker_search
+      params = {
+        :accept => :json
+      }
+      params[:user] = @upstream_username unless @upstream_username.empty?
+      params[:password] = @upstream_password unless @upstream_password.empty?
+      begin
+        results = RestClient.get(@uri.to_s + "v1/search?q=*", params)
+        JSON.parse(results)['results'].each do |result|
+          @found << result['name']
+        end
+      rescue
+        results = RestClient.get(@uri.to_s + "v2/_catalog", params)
+        @found = JSON.parse(results)['repositories']
+      end
+      @found.sort!
+    end
+
     def http_crawl(resume_point)
       Anemone.crawl(resume_point, @proxy) do |anemone|
         anemone.focus_crawl do |page|

data/app/lib/katello/resources/candlepin.rb

@@ -149,8 +149,8 @@ module Katello
             self.put(path(uuid), {:lastCheckin => checkin_date}.to_json, self.default_headers).body
           end
 
-          def available_pools(uuid, listall = false)
-            url = Pool.path + "?consumer=#{uuid}&listall=#{listall}"
+          def available_pools(owner_label, uuid, listall = false)
+            url = Pool.path(nil, owner_label) + "?consumer=#{uuid}&listall=#{listall}"
             response = Candlepin::CandlepinResource.get(url, self.default_headers).body
             JSON.parse(response)
           end
@@ -246,16 +246,28 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access(JSON.parse(result))
           end
 
-          def update_content_override(id, content_label, name, value = nil)
-            attrs = [{ :contentLabel => content_label, :name => name }]
-            if value
-              attrs[0][:value] = value
+          # expected params
+          # id : UUID of the consumer
+          # content_overrides => Array of entitlement hashes objects
+          def update_content_overrides(id, content_overrides)
+            attrs_to_delete = []
+            attrs_to_update = []
+            content_overrides.each do |content_override|
+              if content_override[:value]
+                attrs_to_update << content_override
+              else
+                attrs_to_delete << content_override
+              end
+            end
+
+            if attrs_to_update.present?
               result = Candlepin::CandlepinResource.put(join_path(path(id), 'content_overrides'),
-                                                        attrs.to_json, self.default_headers)
-            else
+                                                        attrs_to_update.to_json, self.default_headers)
+            end
+            if attrs_to_delete.present?
               client = Candlepin::CandlepinResource.rest_client(Net::HTTP::Delete, :delete,
                                                                 join_path(path(id), 'content_overrides'))
-              client.options[:payload] = attrs.to_json
+              client.options[:payload] = attrs_to_delete.to_json
               result = client.delete({:accept => :json, :content_type => :json}.merge(User.cp_oauth_header))
             end
             ::Katello::Util::Data.array_with_indifferent_access(JSON.parse(result))
@@ -275,9 +287,9 @@ module Katello
 
             uri.scheme = URI.parse(proxy_config[:host]).scheme
             uri.host = URI.parse(proxy_config[:host]).host
-            uri.port = proxy_config[:port]
-            uri.user = proxy_config[:user]
-            uri.password = proxy_config[:password]
+            uri.port = proxy_config[:port].to_s
+            uri.user = proxy_config[:user].to_s
+            uri.password = proxy_config[:password].to_s
 
             RestClient.proxy = uri.to_s
           end
@@ -386,15 +398,15 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access JSON.parse(imports_json)
           end
 
-          def pools(key, filter = {})
-            if key
+          def pools(owner_label, filter = {})
+            filter[:add_future] ||= true
+            params = hash_to_query(filter)
+            if owner_label
               # hash_to_query escapes the ":!" to "%3A%21" which candlepin rejects
-              params = hash_to_query(filter)
-              params += params == '?' ? '' : '&'
-              params += 'attribute=unmapped_guests_only:!true'
-              json_str = self.get(join_path(path(key), 'pools') + params, self.default_headers).body
+              params += '&attribute=unmapped_guests_only:!true'
+              json_str = self.get(join_path(path(owner_label), 'pools') + params, self.default_headers).body
             else
-              json_str = self.get(join_path('candlepin', 'pools') + hash_to_query(filter), self.default_headers).body
+              json_str = self.get(join_path('candlepin', 'pools') + params, self.default_headers).body
             end
             ::Katello::Util::Data.array_with_indifferent_access JSON.parse(json_str)
           end
@@ -510,9 +522,8 @@ module Katello
           end
 
           def get_for_owner(owner_key, include_temporary_guests = false)
-            url_path = "/candlepin/owners/#{owner_key}/pools"
-            url_params = "?attribute=unmapped_guests_only:!true"
-            url = include_temporary_guests ? url_path : url_path + url_params
+            url = "/candlepin/owners/#{owner_key}/pools?add_future=true"
+            url += "&attribute=unmapped_guests_only:!true" if include_temporary_guests
             pools_json = self.get(url, self.default_headers).body
             JSON.parse(pools_json)
           end
@@ -527,39 +538,45 @@ module Katello
             JSON.parse(entitlement_json)
           end
 
-          def path(id = nil)
-            "/candlepin/pools/#{id}"
+          def path(id = nil, owner_label = nil)
+            if owner_label && id
+              "/candlepin/owners/#{owner_label}/pools/#{id}"
+            elsif owner_label
+              "/candlepin/owners/#{owner_label}/pools/"
+            else
+              "/candlepin/pools/#{id}"
+            end
           end
         end
       end
 
       class Content < CandlepinResource
         class << self
-          def create(attrs)
-            JSON.parse(self.post(path, JSON.generate(attrs), self.default_headers).body).with_indifferent_access
+          def create(owner_label, attrs)
+            JSON.parse(self.post(path(owner_label), JSON.generate(attrs), self.default_headers).body).with_indifferent_access
           end
 
-          def get(id)
-            content_json = super(path(id), self.default_headers).body
+          def get(owner_label, id)
+            content_json = super(path(owner_label, id), self.default_headers).body
             JSON.parse(content_json).with_indifferent_access
           end
 
-          def all
-            content_json = Candlepin::CandlepinResource.get(path, self.default_headers).body
+          def all(owner_label)
+            content_json = Candlepin::CandlepinResource.get(path(owner_label), self.default_headers).body
             JSON.parse(content_json)
           end
 
-          def destroy(id)
+          def destroy(owner_label, id)
             fail ArgumentError, "content id has to be specified" unless id
-            self.delete(path(id), self.default_headers).code.to_i
+            self.delete(path(owner_label, id), self.default_headers).code.to_i
           end
 
-          def update(attrs)
-            JSON.parse(self.put(path(attrs[:id] || attrs['id']), JSON.generate(attrs), self.default_headers).body).with_indifferent_access
+          def update(owner_label, attrs)
+            JSON.parse(self.put(path(owner_label, attrs[:id] || attrs['id']), JSON.generate(attrs), self.default_headers).body).with_indifferent_access
           end
 
-          def path(id = nil)
-            "/candlepin/content/#{id}"
+          def path(owner_label, id = nil)
+            "/candlepin/owners/#{owner_label}/content/#{id}"
           end
         end
       end
@@ -589,11 +606,6 @@ module Katello
             JSON.parse(content_json)
           end
 
-          def refresh_for_owner(owner_key)
-            ret = self.put("/candlepin/owners/#{owner_key}/subscriptions", {}.to_json, self.default_headers).body
-            JSON.parse(ret).with_indifferent_access
-          end
-
           def path(id = nil)
             "/candlepin/subscriptions/#{id}"
           end
@@ -622,8 +634,8 @@ module Katello
 
       class Product < CandlepinResource
         class << self
-          def all
-            JSON.parse(Candlepin::CandlepinResource.get(path, self.default_headers).body)
+          def all(owner_label)
+            JSON.parse(Candlepin::CandlepinResource.get(path(owner_label), self.default_headers).body)
           end
 
           def find_for_stacking_id(owner_key, stacking_id)
@@ -635,12 +647,12 @@ module Katello
             nil
           end
 
-          def create(attr)
-            JSON.parse(self.post(path, attr.to_json, self.default_headers).body).with_indifferent_access
+          def create(owner_label, attr)
+            JSON.parse(self.post(path(owner_label), attr.to_json, self.default_headers).body).with_indifferent_access
           end
 
-          def get(id = nil, included = [])
-            products_json = super(path(id + "/?#{included_list(included)}"), self.default_headers).body
+          def get(owner_label, id = nil, included = [])
+            products_json = super(path(owner_label, id + "/?#{included_list(included)}"), self.default_headers).body
             products = JSON.parse(products_json)
             products = [products] unless id.nil?
             ::Katello::Util::Data.array_with_indifferent_access products
@@ -674,17 +686,17 @@ module Katello
             self.product_certificate(id, owner).try :[], 'key'
           end
 
-          def destroy(product_id)
+          def destroy(owner_label, product_id)
             fail ArgumentError, "product id has to be specified" unless product_id
-            self.delete(path(product_id), self.default_headers).code.to_i
+            self.delete(path(owner_label, product_id), self.default_headers).code.to_i
           end
 
-          def add_content(product_id, content_id, enabled)
-            self.post(join_path(path(product_id), "content/#{content_id}?enabled=#{enabled}"), nil, self.default_headers).code.to_i
+          def add_content(owner_label, product_id, content_id, enabled)
+            self.post(join_path(path(owner_label, product_id), "content/#{content_id}?enabled=#{enabled}"), nil, self.default_headers).code.to_i
           end
 
-          def remove_content(product_id, content_id)
-            self.delete(join_path(path(product_id), "content/#{content_id}"), self.default_headers).code.to_i
+          def remove_content(owner_label, product_id, content_id)
+            self.delete(join_path(path(owner_label, product_id), "content/#{content_id}"), self.default_headers).code.to_i
           end
 
           def create_unlimited_subscription(owner_key, product_id)
@@ -721,16 +733,11 @@ module Katello
                 end
               end
             end
-
-            if update_subscriptions
-              return Candlepin::Subscription.refresh_for_owner owner_key
-            else
-              return nil
-            end
+            nil
           end
 
-          def path(id = nil)
-            "/candlepin/products/#{id}"
+          def path(owner_label, id = nil)
+            "/candlepin/owners/#{owner_label}/products/#{id}"
           end
         end
       end
@@ -815,16 +822,28 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access(JSON.parse(result))
           end
 
-          def update_content_override(id, content_label, name, value = nil)
-            attrs = [{ :contentLabel => content_label, :name => name }]
-            if value
-              attrs[0][:value] = value
+          # expected params
+          # id : ID of the Activation Key
+          # content_overrides => Array of content override hashes
+          def update_content_overrides(id, content_overrides)
+            attrs_to_delete = []
+            attrs_to_update = []
+            content_overrides.each do |content_override|
+              if content_override[:value]
+                attrs_to_update << content_override
+              else
+                attrs_to_delete << content_override
+              end
+            end
+
+            if attrs_to_update.present?
               result = Candlepin::CandlepinResource.put(join_path(path(id), 'content_overrides'),
-                                                        attrs.to_json, self.default_headers)
-            else
+                                                        attrs_to_update.to_json, self.default_headers)
+            end
+            if attrs_to_delete.present?
               client = Candlepin::CandlepinResource.rest_client(Net::HTTP::Delete, :delete,
                                                                 join_path(path(id), 'content_overrides'))
-              client.options[:payload] = attrs.to_json
+              client.options[:payload] = attrs_to_delete.to_json
               result = client.delete({:accept => :json, :content_type => :json}.merge(User.cp_oauth_header))
             end
             ::Katello::Util::Data.array_with_indifferent_access(JSON.parse(result))