katello 3.10.2 → 3.11.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60a32175969fbaf3d07e70d2d7eeaa593be7e0a43495475c777321e4c0412c9a
-  data.tar.gz: b3bf8a7d38822fef072ce04c26759e1456d028a154eac96fb3d1583b3900c550
+  metadata.gz: 6a32463caf56384a932ac684b0b75d47c98ae21e6b3b3bbca2b66a4f0cf6d5c9
+  data.tar.gz: 708211d7fd9d19eebf438ae7656aba6425bbeab7e93118adc44480af84e48b5c
 SHA512:
-  metadata.gz: c60fb44171334e6ab716824ec893b35489d9ce5c6b1f2620fdd8e416b60d7b9f787a6b0311c48e50cfe9010f7aca4635d314ff7309c31d972b5071359e3f3ef6
-  data.tar.gz: 5e2b0a41509fa090c341676c5946ff8e939b77909be7777b9185f138bb7a94a970cdf8cc4ebf2247ff28ba3568da3396c6c17c09dfcae7f91b1b4a2d71f438e8
+  metadata.gz: 80f6db1719414ea26a9391e4a245961a580b050c62e0f8dfa355fe9d00398e629c2b04c87e810b374af8a0328497881301e110f9b090ef48888d2f6d368df948
+  data.tar.gz: b9676a10313f563208e0982ecdf209886ea17d19755ffe52f42303ebed127ce42994c35bca39e3fd016e442b67edbe3f2a68340a3b58c57f7006783949a67f51

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -374,43 +374,37 @@ module Katello
     def upload_manifest(tar_file)
       upload_id = pulp_content.create_upload_request['upload_id']
       filename = tmp_file(tar_file)
-      File.open(filename, 'rb') do |file|
-        pulp_content.upload_bits(upload_id, 0, file.read)
+      uploads = []
 
-        file.rewind
+      File.open(filename, 'rb') do |file|
         content = file.read
-        unit_keys = [{
+        pulp_content.upload_bits(upload_id, 0, content)
+
+        uploads << {
+          id: upload_id,
           name: filename,
           size: file.size,
           checksum: Digest::SHA256.hexdigest(content)
-        }]
-        unit_type_id = 'docker_manifest'
-        task = sync_task(::Actions::Katello::Repository::ImportUpload,
-                         @repository, [upload_id], :unit_type_id => unit_type_id,
-                         :unit_keys => unit_keys,
-                         :generate_metadata => true, :sync_capsule => true)
-        digest = task.output['upload_results'][0]['digest']
-
-        File.delete(filename)
-
-        digest
+        }
       end
+
+      File.delete(filename)
+      task = sync_task(::Actions::Katello::Repository::ImportUpload,
+                       @repository, uploads, generate_metadata: true, sync_capsule: true)
+      task.output['upload_results'][0]['digest']
     ensure
       pulp_content.delete_upload_request(upload_id) if upload_id
     end
 
     def upload_tag(digest, tag)
       upload_id = pulp_content.create_upload_request['upload_id']
-      unit_keys = [{
+      uploads = [{
+        id: upload_id,
         name: tag,
         digest: digest
       }]
-      unit_type_id = 'docker_tag'
-      sync_task(::Actions::Katello::Repository::ImportUpload,
-                       @repository, [upload_id], :unit_type_id => unit_type_id,
-                       :unit_keys => unit_keys,
-                       :generate_metadata => true, :sync_capsule => true)
-
+      sync_task(::Actions::Katello::Repository::ImportUpload, @repository, uploads,
+                :generate_metadata => true, :sync_capsule => true)
       tag
     ensure
       pulp_content.delete_upload_request(upload_id) if upload_id

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

@@ -9,7 +9,7 @@ module Katello
     api :POST, "/repositories/:repository_id/content_uploads", N_("Create an upload request")
     param :repository_id, :number, :required => true, :desc => N_("repository id")
     def create
-      render :json => pulp_content.create_upload_request
+      render :json => @repository.backend_content_service(::SmartProxy.pulp_master).create_upload
     end
 
     api :PUT, "/repositories/:repository_id/content_uploads/:id", N_("Upload a chunk of the file's content")
@@ -18,7 +18,8 @@ module Katello
     param :offset, :number, :required => true, :desc => N_("The offset in the file where the content starts")
     param :content, File, :required => true, :desc => N_("The actual file contents")
     def update
-      pulp_content.upload_bits(params[:id], params[:offset], params[:content])
+      @repository.backend_content_service(::SmartProxy.pulp_master)
+        .upload_chunk(params[:id], params[:offset], params[:content])
       head :no_content
     end
 
@@ -26,16 +27,12 @@ module Katello
     param :repository_id, :number, :required => true, :desc => N_("Repository id")
     param :id, :number, :required => true, :desc => N_("Upload request id")
     def destroy
-      pulp_content.delete_upload_request(params[:id])
+      @repository.backend_content_service(::SmartProxy.pulp_master).delete_upload(params[:id])
       head :no_content
     end
 
     private
 
-    def pulp_content
-      Katello.pulp_server.resources.content
-    end
-
     def find_repository
       @repository = Repository.find(params[:repository_id])
     end

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

@@ -9,7 +9,6 @@ module Katello
     param :content_view_id, :number, :desc => N_("content view identifier"), :required => true
     param :name, String, :desc => N_("name of the puppet module")
     param :author, String, :desc => N_("author of the puppet module")
-    param :uuid, String, :desc => N_("the uuid of the puppet module to associate")
     param_group :search, ::Katello::Api::V2::ApiController
     def index
       respond(:collection => scoped_search(index_relation.distinct, :name, :asc))
@@ -21,9 +20,9 @@ module Katello
     param :name, String, :desc => N_("name of the puppet module")
     param :author, String, :desc => N_("author of the puppet module")
     param :id, String, :desc => N_("the id of the puppet module to associate")
-    param :uuid, String, :desc => N_("the uuid of the puppet module to associate")
+    param :uuid, String, :desc => N_("the uuid of the puppet module to associate"), :deprecated => true
     def create
-      params[:content_view_puppet_module][:uuid] ||= PuppetModule.find(params[:id]).try(:uuid) if params[:id]
+      params[:content_view_puppet_module][:uuid] ||= PuppetModule.find(params[:id]).try(:pulp_id) if params[:id]
       respond resource: ContentViewPuppetModule.create!(puppet_module_params.merge(content_view: @view))
     end
 
@@ -40,7 +39,7 @@ module Katello
     param :id, :number, :desc => N_("puppet module ID"), :required => true
     param :name, String, :desc => N_("name of the puppet module")
     param :author, String, :desc => N_("author of the puppet module")
-    param :uuid, String, :desc => N_("the uuid of the puppet module to associate")
+    param :uuid, String, :desc => N_("the uuid of the puppet module to associate"), :deprecated => true
     def update
       @puppet_module.update_attributes!(puppet_module_params)
       respond :resource => @puppet_module
@@ -58,7 +57,7 @@ module Katello
     def index_relation
       puppet_modules = ContentViewPuppetModule.where(:content_view_id => @view)
       puppet_modules = puppet_modules.where(:name => params[:name]) if params[:name]
-      puppet_modules = puppet_modules.where(:uuid => params[:uuid]) if params[:uuid]
+      puppet_modules = puppet_modules.where(:pulp_id => params[:uuid]) if params[:uuid]
       puppet_modules = puppet_modules.where(:author => params[:author]) if params[:author]
       puppet_modules
     end

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

@@ -128,10 +128,10 @@ module Katello
     param :resolve_dependencies, :bool, :desc => N_("If true, when adding the specified errata or packages, any needed dependencies will be copied as well")
     param :propagate_all_composites, :bool, :desc => N_("If true, will publish a new composite version using any specified content_view_version_id that has been promoted to a lifecycle environment")
     param :add_content, Hash do
-      param :errata_ids, Array, :desc => "Errata ids or uuids to copy into the new versions"
-      param :package_ids, Array, :desc => "Package ids or uuids to copy into the new versions"
-      param :deb_ids, Array, :desc => "Deb Package ids or uuids to copy into the new versions"
-      param :puppet_module_ids, Array, :desc => "Puppet Module ids or uuids to copy into the new versions"
+      param :errata_ids, Array, :desc => "Errata ids to copy into the new versions"
+      param :package_ids, Array, :desc => "Package ids to copy into the new versions"
+      param :deb_ids, Array, :desc => "Deb Package ids to copy into the new versions"
+      param :puppet_module_ids, Array, :desc => "Puppet Module ids to copy into the new versions"
     end
     param :update_hosts, Hash, :desc => N_("After generating the incremental update, apply the changes to the specified hosts.  Only Errata are supported currently.") do
       param :included, Hash, :required => true, :action_aware => true do

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

@@ -130,7 +130,7 @@ module Katello
           end
         end
       end
-      query = query.where("#{PuppetModule.table_name}.uuid NOT in (?)", current_uuids) if current_uuids.present?
+      query = query.where("#{PuppetModule.table_name}.pulp_id NOT in (?)", current_uuids) if current_uuids.present?
       custom_sort = ->(sort_query) { sort_query.order('author, name, sortable_version DESC') }
       sorted_records = scoped_search(query, nil, nil, :resource_class => PuppetModule, :custom_sort => custom_sort)
       if params[:name]
@@ -246,8 +246,8 @@ module Katello
         top_rec = records[0]
         latest = top_rec.dup
         latest.version = _("Always Use Latest (currently %{version})") % { version: latest.version }
-        latest.uuid = nil
-        module_records.delete(top_rec) if selected_latest_versions.include?(top_rec.uuid)
+        latest.pulp_id = nil
+        module_records.delete(top_rec) if selected_latest_versions.include?(top_rec.pulp_id)
         module_records.push(latest)
       end
       module_records

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

@@ -10,7 +10,7 @@ module Katello
     end
 
     def filter_by_content_view_filter(filter)
-      resource_class.where(:uuid => filter.send("#{singular_resource_name}_rules").pluck(:uuid))
+      resource_class.where(:pulp_id => filter.send("#{singular_resource_name}_rules").pluck(:uuid))
     end
 
     def custom_index_relation(collection)

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

@@ -95,8 +95,8 @@ module Katello
 
     def filter_by_content_view(filter, collection)
       repos = Katello::ContentView.find(filter.content_view_id).repositories
-      uuid = repos.map { |r| r.send("errata").pluck("uuid") }.flatten
-      filter_by_ids(uuid, collection)
+      ids = repos.map { |r| r.send(:erratum_ids) }.flatten
+      filter_by_ids(ids, collection)
     end
 
     def filter_by_content_view_filter(filter, collection)

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

@@ -305,9 +305,7 @@ module Katello
 
     def content_action
       if params[:content_type] == 'errata'
-        errata_uuids = Katello::Erratum.where(:errata_id => params[:content]).pluck(:uuid)
-        errata_uuids += Katello::Erratum.where(:uuid => params[:content]).pluck(:uuid)
-        task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, @hosts, errata_uuids.uniq)
+        task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, @hosts, params[:content].uniq)
         respond_for_async :resource => task
       else
         content = params[:content]

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

@@ -59,10 +59,10 @@ module Katello
       collection_ids = []
       current_ids = filter.package_group_rules.map(&:uuid)
       filter.applicable_repos.each do |repo|
-        collection_ids.concat(repo.package_groups.map(&:uuid))
+        collection_ids.concat(repo.package_groups.map(&:pulp_id))
       end
-      collection = PackageGroup.where(:uuid => collection_ids)
-      collection = collection.where("uuid not in (?)", current_ids) unless current_ids.empty?
+      collection = PackageGroup.where(:pulp_id => collection_ids)
+      collection = collection.where("pulp_id not in (?)", current_ids) unless current_ids.empty?
       collection
     end
 

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

@@ -197,7 +197,7 @@ module Katello
     param_group :repo_create
     param_group :repo
     def create
-      repo_params = filtered_repository_params
+      repo_params = repository_params
       unless RepositoryTypeManager.creatable_by_user?(repo_params[:content_type])
         msg = _("Invalid params provided - content_type must be one of %s") % RepositoryTypeManager.creatable_repository_types.keys.join(",")
         fail HttpErrors::UnprocessableEntity, msg
@@ -389,22 +389,11 @@ module Katello
         params[:upload_ids].each { |upload_id| uploads << {'id' => upload_id} }
       end
 
-      upload_ids = uploads.map { |upload| upload['id'] }
-      unit_keys = uploads.map do |upload|
-        if @repository.file? || @repository.docker?
-          upload.except('id')
-        else
-          upload.except('id').except('name')
-        end
-      end
-
-      unit_type_id = unit_keys[0] && unit_keys[0].include?('digest') ? 'docker_tag' : @repository.unit_type_id
-
       begin
-        task = send(async ? :async_task : :sync_task, ::Actions::Katello::Repository::ImportUpload,
-                    @repository, upload_ids, :unit_type_id => unit_type_id, :unit_keys => unit_keys,
-                    :generate_metadata => generate_metadata, :sync_capsule => sync_capsule)
-        respond_for_async(resource: task)
+        respond_for_async(resource: send(
+          async ? :async_task : :sync_task,
+          ::Actions::Katello::Repository::ImportUpload, @repository, uploads,
+          generate_metadata: generate_metadata, sync_capsule: sync_capsule))
       rescue => e
         raise HttpErrors::BadRequest, e.message
       end
@@ -451,14 +440,6 @@ module Katello
       end
     end
 
-    def filtered_repository_params
-      params = repository_params
-      ::Katello::RootRepository::CONTENT_ATTRIBUTE_RESTRICTIONS.each do |attribute, types|
-        params.delete(attribute) unless types.include?(params[:content_type])
-      end
-      params
-    end
-
     def repository_params
       keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username,
               :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, :ignore_global_proxy,

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

@@ -125,7 +125,7 @@ module Katello
         @product_content = @product.product_content_by_id(params[:id])
       else
         content = Katello::Content.find_by(:cp_content_id => params[:id], :organization_id => @organization[:id])
-        @product_content = Katello::ProductContent.find_by(:content_id => content.id)
+        @product_content = Katello::ProductContent.find_by(:id => content[:id])
       end
       fail HttpErrors::NotFound, _("Couldn't find repository set with id '%s'.") % params[:id] if @product_content.nil?
       @product = @product_content.product if @product.nil?

data/app/controllers/katello/application_controller.rb

@@ -11,7 +11,7 @@ module Katello
     helper ::ApplicationHelper
 
     before_action :set_gettext_locale
-    helper_method :current_organization
+    helper_method :current_organization_object
     before_action :require_org
 
     protect_from_forgery # See ActionController::RequestForgeryProtection for details
@@ -49,7 +49,7 @@ module Katello
       'generic'
     end
 
-    def current_organization
+    def current_organization_object
       if !session[:current_organization_id]
         @current_org = Organization.current
         return @current_org
@@ -72,14 +72,14 @@ module Katello
       end
     end
 
-    def current_organization=(org)
+    def current_organization_object=(org)
       session[:current_organization_id] = org.try(:id)
     end
 
     private # why bother? methods below are not testable/tested
 
     def require_org
-      unless session && current_organization
+      unless session && current_organization_object
         redirect_to '/select_organization?toState=' + request.path
       end
     end

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

@@ -151,7 +151,7 @@ module Katello
       end
 
       def filter_by_ids(ids, collection)
-        collection.with_uuid(ids)
+        collection.with_identifiers(ids)
       end
 
       def find_repository

data/app/controllers/katello/sync_management_controller.rb

@@ -17,7 +17,7 @@ module Katello
     end
 
     def index
-      org = current_organization
+      org = current_organization_object
       @products = org.library.products.readable
       redhat_products, custom_products = @products.partition(&:redhat?)
       redhat_products.sort_by { |p| p.name.downcase }

data/app/helpers/katello/errata_mailer_helper.rb

@@ -14,7 +14,7 @@ module Katello
     end
 
     def erratum_path(erratum)
-      "#{Setting[:foreman_url]}/errata/#{erratum.uuid}"
+      "#{Setting[:foreman_url]}/errata/#{erratum.id}"
     end
 
     def repository_erratum_path(repository, type = nil)

data/app/helpers/katello/sync_management_helper.rb

@@ -25,7 +25,7 @@ module Katello
     end
 
     def any_syncable?
-      Product.syncable? && current_organization.syncable_content?
+      Product.syncable? && current_organization_object.syncable_content?
     end
 
     def error_state?(status)

data/app/lib/actions/candlepin/environment/add_content_to_environment.rb

@@ -0,0 +1,18 @@
+module Actions
+  module Candlepin
+    module Environment
+      class AddContentToEnvironment < Candlepin::Abstract
+        input_format do
+          param :view_env_cp_id
+          param :content_id
+        end
+
+        def run
+          output[:add_response] = ::Katello::Resources::Candlepin::Environment.add_content(input[:view_env_cp_id], [input[:content_id]])
+        rescue RestClient::Conflict
+          Rails.logger.info("attempted to add content ID #{input[:content_id]} to environment, but content ID already exists.")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/content_view_puppet_environment/clone.rb

@@ -25,10 +25,7 @@ module Actions
               clone = setup_puppet_environment_clone(from_version, clone)
 
               self.new_puppet_environment = clone
-              plan_action(Pulp::Repository::CopyPuppetModule,
-                          source_pulp_id: source.pulp_id,
-                          target_pulp_id: clone.pulp_id,
-                          criteria: nil)
+              plan_action(Pulp::ContentViewPuppetEnvironment::CopyContents, clone, :source_content_view_puppet_environment_id => source.id)
 
               concurrence do
                 plan_action(Katello::Repository::MetadataGenerate, clone) if environment

data/app/lib/actions/katello/content_view_puppet_environment/clone_content_for_version.rb

@@ -0,0 +1,20 @@
+module Actions
+  module Katello
+    module ContentViewPuppetEnvironment
+      class CloneContentForVersion < Actions::Base
+        def plan(puppet_environment, modules_by_repoid)
+          sequence do
+            concurrence do
+              modules_by_repoid.each_pair do |repo_id, modules|
+                source_repo = ::Katello::Repository.find(repo_id)
+
+                plan_action(Pulp::ContentViewPuppetEnvironment::CopyContents, puppet_environment,
+                            puppet_modules: modules, source_repository_id: source_repo.id)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/content_view_puppet_environment/create_for_version.rb

@@ -7,13 +7,14 @@ module Actions
 
         def plan(content_view_version)
           content_view = content_view_version.content_view
-          modules_by_repoid = content_view.computed_module_ids_by_repoid
+          modules_by_repoid = content_view.computed_modules_by_repoid
 
           self.new_puppet_environment = content_view.build_puppet_env(:version => content_view_version)
 
           sequence do
             plan_action(ContentViewPuppetEnvironment::Create, new_puppet_environment, true)
-            plan_action(ContentViewPuppetEnvironment::CloneContent, new_puppet_environment, modules_by_repoid)
+            plan_action(ContentViewPuppetEnvironment::CloneContentForVersion, new_puppet_environment, modules_by_repoid)
+            plan_action(Pulp::ContentViewPuppetEnvironment::IndexContent, id: new_puppet_environment.id)
           end
         end
       end

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

@@ -219,10 +219,10 @@ module Actions
           copy_outputs = []
           if new_repo.content_type == ::Katello::Repository::DEB_TYPE
             unless deb_ids.blank?
-              deb_uuids = ::Katello::Deb.with_identifiers(deb_ids).pluck(:uuid)
-              copy_outputs << plan_copy(Pulp::Repository::CopyDeb, new_repo.library_instance, new_repo,
-                                        { :filters => {:association => {'unit_id' => {'$in' => deb_uuids}}}},
-                                        :recursive => true, :resolve_dependencies => dep_solve).output
+              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
+                                          ::Katello::Deb.with_identifiers(deb_ids),
+                                        recursive: true,
+                                        resolve_dependencies: dep_solve).output
             end
           end
           copy_outputs
@@ -232,17 +232,16 @@ module Actions
           copy_outputs = []
           if new_repo.content_type == ::Katello::Repository::YUM_TYPE
             unless errata_ids.blank?
-              errata_uuids = ::Katello::Erratum.with_identifiers(errata_ids).pluck(:uuid)
-              copy_outputs << plan_copy(Pulp::Repository::CopyErrata, new_repo.library_instance, new_repo,
-                                        { :filters => {:association => {'unit_id' => {'$in' => errata_uuids}}}},
-                                        :recursive => true, :resolve_dependencies => dep_solve).output
+              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
+                                        ::Katello::Erratum.with_identifiers(errata_ids),
+                                        recursive: true,
+                                        resolve_dependencies: dep_solve).output
             end
 
             unless package_ids.blank?
-              package_uuids = ::Katello::Rpm.with_identifiers(package_ids).pluck(:uuid)
-              copy_outputs << plan_copy(Pulp::Repository::CopyRpm, new_repo.library_instance, new_repo,
-                                        { :filters => {:association => {'unit_id' => {'$in' => package_uuids}}}},
-                                        :resolve_dependencies => dep_solve).output
+              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
+                                        ::Katello::Rpm.with_identifiers(package_ids),
+                                        resolve_dependencies: dep_solve).output
             end
           end
           copy_outputs
@@ -270,11 +269,11 @@ module Actions
           ::Katello::PuppetModule.with_identifiers(ids)
         end
 
-        def copy_puppet_module(new_repo, module_id)
+        def copy_puppet_modules(new_repo, module_id)
           puppet_module = find_puppet_modules([module_id]).first
-          possible_repos = puppet_module.repositories.in_organization(new_repo.organization).in_default_view
-          plan_action(Pulp::Repository::CopyPuppetModule, :source_pulp_id => possible_repos.first.pulp_id,
-                    :target_pulp_id => new_repo.pulp_id, :clauses => {'unit_id' => puppet_module.uuid}, :include_result => true)
+          possible_repos = puppet_module.repositories.in_organization(new_repo.organization).in_default_vie
+          plan_action(Pulp::Repository::CopyUnits, possible_repos.first, new_repo,
+                                                  [puppet_module])
         end
 
         def plan_copy(action_class, source_repo, target_repo, clauses = nil, override_config = nil)