katello 3.18.0.rc1 → 4.0.0.rc1

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

@@ -107,7 +107,7 @@ module Katello
 
     def find_products
       params.require(:ids)
-      @products = Product.where(:id => params[:ids])
+      @products = Product.readable.where(:id => params[:ids])
     end
   end
 end

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

@@ -4,7 +4,7 @@ module Katello
 
     before_action :find_activation_key, :only => [:index]
     before_action :find_organization, :only => [:create, :index, :auto_complete_search]
-    before_action :find_product, :only => [:update, :destroy, :sync]
+    before_action :find_authorized_katello_resource, :only => [:update, :destroy, :sync]
     before_action :find_organization_from_product, :only => [:update]
     before_action :authorize_gpg_key, :only => [:update, :create]
     before_action :authorize_ssl_ca_cert, :only => [:update, :create]
@@ -131,14 +131,14 @@ module Katello
     protected
 
     def find_product(options = {})
-      @product = Product.includes(options[:includes] || []).find_by(:id => params[:id])
-      fail HttpErrors::NotFound, _("Couldn't find product '%s'") % params[:id] unless @product
+      @product = Product.includes(options[:includes] || []).readable.find_by(:id => params[:id])
+      throw_resource_not_found(name: 'product', id: params[:id]) if @product.nil?
     end
 
     def find_activation_key
       if params[:activation_key_id]
-        @activation_key = ActivationKey.find_by(:id => params[:activation_key_id])
-        fail HttpErrors::NotFound, _("Couldn't find activation key '%s'") % params[:activation_key_id] if @activation_key.nil?
+        @activation_key = ActivationKey.readable.find_by(:id => params[:activation_key_id])
+        throw_resource_not_found(name: 'Activation Key', id: params[:activation_key_id]) if @activation_key.nil?
         @organization = @activation_key.organization
       end
     end
@@ -151,7 +151,7 @@ module Katello
       gpg_key_id = product_params[:gpg_key_id]
       if gpg_key_id
         gpg_key = GpgKey.readable.where(:id => gpg_key_id, :organization_id => @organization).first
-        fail HttpErrors::NotFound, _("Couldn't find gpg key '%s'") % gpg_key_id if gpg_key.nil?
+        throw_resource_not_found(name: 'gpg key', id: gpg_key_id) if gpg_key.nil?
       end
     end
 
@@ -159,7 +159,7 @@ module Katello
       ssl_ca_cert_id = product_params[:ssl_ca_cert_id]
       if ssl_ca_cert_id
         ssl_ca_cert = GpgKey.readable.where(:id => ssl_ca_cert_id, :organization_id => @organization).first
-        fail HttpErrors::NotFound, _("Couldn't find ssl ca cert '%s'") % ssl_ca_cert_id if ssl_ca_cert.nil?
+        throw_resource_not_found(name: 'ssl ca cert', id: ssl_ca_cert_id) if ssl_ca_cert.nil?
       end
     end
 
@@ -167,7 +167,7 @@ module Katello
       ssl_client_cert_id = product_params[:ssl_client_cert_id]
       if ssl_client_cert_id
         ssl_client_cert = GpgKey.readable.where(:id => ssl_client_cert_id, :organization_id => @organization).first
-        fail HttpErrors::NotFound, _("Couldn't find ssl client cert '%s'") % ssl_client_cert_id if ssl_client_cert.nil?
+        throw_resource_not_found(name: 'ssl client cert', id: ssl_client_cert_id) if ssl_client_cert.nil?
       end
     end
 
@@ -175,7 +175,7 @@ module Katello
       ssl_client_key_id = product_params[:ssl_client_key_id]
       if ssl_client_key_id
         ssl_client_key = GpgKey.readable.where(:id => ssl_client_key_id, :organization_id => @organization).first
-        fail HttpErrors::NotFound, _("Couldn't find ssl client key '%s'") % ssl_client_key_id if ssl_client_key.nil?
+        throw_resource_not_found(name: 'ssl client key', id: ssl_client_key_id) if ssl_client_key.nil?
       end
     end
 

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

@@ -25,7 +25,6 @@ module Katello
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_KEY_TYPE }
-    before_action :check_ignore_global_proxy, :only => [ :update, :create ]
     skip_before_action :authorize, :only => [:gpg_key_content]
     skip_before_action :check_media_type, :only => [:upload_content]
 
@@ -45,7 +44,7 @@ module Katello
       param :checksum_type, String, :desc => N_("Checksum of the repository, currently 'sha1' & 'sha256' are supported")
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
       param :docker_tags_whitelist, Array, :desc => N_("Comma-separated list of tags to sync for Container Image repository")
-      param :download_policy, ["immediate", "on_demand", "background"], :desc => N_("download policy for yum repos (either 'immediate', 'on_demand', or 'background (deprecated)')")
+      param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum repos (either 'immediate' or 'on_demand')")
       param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
       param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed")
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
@@ -56,11 +55,11 @@ module Katello
       param :deb_releases, String, :desc => N_("comma-separated list of releases to be synced from deb-archive")
       param :deb_components, String, :desc => N_("comma-separated list of repo components to be synced from deb-archive")
       param :deb_architectures, String, :desc => N_("comma-separated list of architectures to be synced from deb-archive")
-      param :ignore_global_proxy, :bool, :desc => N_("if true, will ignore the globally configured proxy when syncing"), :deprecated => true
       param :ignorable_content, Array, :desc => N_("List of content units to ignore while syncing a yum repository. Must be subset of %s") % RootRepository::IGNORABLE_CONTENT_UNIT_TYPES.join(",")
       param :ansible_collection_requirements, String, :desc => N_("Contents of requirement yaml file to sync from URL")
       param :http_proxy_policy, ::Katello::RootRepository::HTTP_PROXY_POLICIES, :desc => N_("policies for HTTP proxy for content sync")
       param :http_proxy_id, :number, :desc => N_("ID of a HTTP Proxy")
+      param :arch, String, :desc => N_("Architecture of content in the repository")
     end
 
     def_param_group :repo_create do
@@ -95,6 +94,7 @@ module Katello
     param :available_for, String, :desc => N_("interpret specified object to return only Repositories that can be associated with specified object.  Only 'content_view' & 'content_view_version' are supported."),
           :required => false
     param :with_content, RepositoryTypeManager.enabled_content_types, :desc => N_("only repositories having at least one of the specified content type ex: rpm , erratum")
+    param :download_policy, ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES, :desc => N_("limit to only repositories with this download policy")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Repository)
     def index
@@ -138,6 +138,7 @@ module Katello
     def index_relation_product(query)
       query = query.joins(:root => :product).where("#{Product.table_name}.organization_id" => @organization) if @organization
       query = query.joins(:root).where("#{RootRepository.table_name}.product_id" => @product.id) if @product
+      query = query.joins(:root).where("#{RootRepository.table_name}.download_policy" => params[:download_policy]) if params[:download_policy]
       query
     end
 
@@ -224,10 +225,6 @@ module Katello
         fail HttpErrors::UnprocessableEntity, msg
       end
 
-      if repo_params['content_type'] == "puppet" || repo_params['content_type'] == "ostree"
-        ::Foreman::Deprecation.api_deprecation_warning("Puppet and OSTree will no longer be supported in Katello 4.0")
-      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)
@@ -493,17 +490,6 @@ module Katello
       params.require(:repository).permit(*keys).to_h.with_indifferent_access
     end
 
-    def check_ignore_global_proxy
-      if params.key?(:ignore_global_proxy)
-        ::Foreman::Deprecation.api_deprecation_warning("The parameter ignore_global_proxy will be removed in a future Katello release. Please update to use the http_proxy_policy parameter.")
-        if ::Foreman::Cast.to_bool(params[:ignore_global_proxy])
-          params[:repository][:http_proxy_policy] = RootRepository::NO_DEFAULT_HTTP_PROXY
-        else
-          params[:repository][:http_proxy_policy] = RootRepository::GLOBAL_DEFAULT_HTTP_PROXY
-        end
-      end
-    end
-
     def get_content_credential(repo_params, content_type)
       credential_value = @product.send(content_type)
 
@@ -515,7 +501,7 @@ module Katello
     end
 
     # rubocop:disable Metrics/CyclomaticComplexity
-    def construct_repo_from_params(repo_params)
+    def construct_repo_from_params(repo_params) # rubocop:disable Metrics/AbcSize
       root = @product.add_repo(repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                             :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
                                                             :checksum_type, :download_policy, :http_proxy_policy).to_h.with_indifferent_access)

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

@@ -4,8 +4,11 @@ module Katello
 
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_action :find_product_or_organization
+    before_action :set_readable_product_scope, only: [:index, :show, :available_repositories, :auto_complete_search]
+    before_action :set_editable_product_scope, only: [:enable, :disable]
+    before_action :find_product
     before_action :custom_product?
+    before_action :find_organization
     before_action :find_product_content, :except => [:index, :auto_complete_search]
 
     resource_description do
@@ -102,7 +105,8 @@ module Katello
 
     def index_relation
       if @product.nil?
-        relation = @organization.product_contents.displayable
+        authorized_product_contents = Katello::ProductContent.joins(:product).merge(@product_scope)
+        relation = @organization.product_contents.merge(authorized_product_contents).displayable
       else
         relation = @product.displayable_product_contents
       end
@@ -125,25 +129,31 @@ module Katello
       if @product.present?
         @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)
+        content = Katello::Content.where(cp_content_id: params[:id], organization: @organization)
+        authorized_product_contents = Katello::ProductContent.joins(:product).merge(@product_scope)
+        @product_content = authorized_product_contents.joins(:content).merge(content).first
+        @product = @product_content&.product
       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?
+      throw_resource_not_found(name: 'repository set', id: params[:id]) if @product_content.nil?
     end
 
-    def find_product_or_organization
+    def find_product
       if params[:product_id]
-        find_product
-      else
-        @organization = find_organization
+        @product = @product_scope.find_by(id: params[:product_id])
+        throw_resource_not_found(name: 'product', id: params[:product_id]) if @product.nil?
       end
     end
 
-    def find_product
-      @product = Product.find_by(:id => params[:product_id])
-      fail HttpErrors::NotFound, _("Couldn't find product with id '%s'") % params[:product_id] if @product.nil?
-      @organization = @product.organization
+    def set_readable_product_scope
+      @product_scope = Katello::Product.readable
+    end
+
+    def set_editable_product_scope
+      @product_scope = Katello::Product.editable
+    end
+
+    def find_organization
+      @organization = @product&.organization || super
     end
 
     def custom_product?

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

@@ -0,0 +1,34 @@
+module Katello
+  class Api::V2::SimpleContentAccessController < Api::V2::ApiController
+    before_action :find_organization
+    before_action :check_upstream_connection
+
+    resource_description do
+      description "Red Hat subscriptions management platform."
+      api_version 'v2'
+    end
+
+    api :GET, "/organizations/:organization_id/simple_content_access/eligible",
+      N_("Check if the specified organization is eligible for Simple Content Access")
+    def eligible
+      eligible = @organization.upstream_consumer.simple_content_access_eligible?
+      render json: { simple_content_access_eligible: eligible }
+    end
+
+    api :PUT, "/organizations/:organization_id/simple_content_access/enable",
+      N_("Enable simple content access for a manifest")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def enable
+      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
+      respond_for_async :resource => task
+    end
+
+    api :PUT, "/organizations/:organization_id/simple_content_access/disable",
+      N_("Disable simple content access for a manifest")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def disable
+      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
+      respond_for_async :resource => task
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ module Katello
                         :start_date, :end_date, :available, :quantity, :account_number, :contract_number,
                         :support_level, :ram, :stacking_id, :multi_entitlement, :type, :product_id,
                         :unmapped_guest, :virt_only, :virt_who, :upstream?],
-                       ['Pool Id', 'Subscription Id', 'Name', 'Candlepin Id', 'Organization Id',
+                       ['Pool Id Number', 'Subscription Id', 'Name', 'Pool Id', 'Organization Id',
                         'Sockets', 'Cores', 'Start Date', 'End Date', 'Available', 'Quantity', 'Account Number',
                         'Contract Number', 'Support Level', 'RAM', 'Stacking Id', 'Multi Entitlement', 'Type',
                         'Product Id', 'Unmapped Guest', 'Virt Only', 'Requires Virt Who', 'Upstream'])

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

@@ -2,7 +2,7 @@ module Katello
   class Api::V2::UpstreamSubscriptionsController < Api::V2::ApiController
     before_action :find_organization
     before_action :check_upstream_connection
-
+    before_action :deprecated, only: [:simple_content_access_eligible, :enable_simple_content_access, :disable_simple_content_access]
     resource_description do
       description "Red Hat subscriptions management platform."
       api_version 'v2'
@@ -78,14 +78,14 @@ module Katello
     end
 
     api :GET, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/eligible",
-      N_("Check if the specified organization is eligible for Simple Content Access")
+      N_("Check if the specified organization is eligible for Simple Content Access"), :deprecated => true
     def simple_content_access_eligible
       eligible = @organization.upstream_consumer.simple_content_access_eligible?
       render json: { simple_content_access_eligible: eligible }
     end
 
     api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/enable",
-      N_("Enable simple content access for a manifest")
+      N_("Enable simple content access for a manifest"), :deprecated => true
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def enable_simple_content_access
       task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
@@ -93,7 +93,7 @@ module Katello
     end
 
     api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/disable",
-      N_("Disable simple content access for a manifest")
+      N_("Disable simple content access for a manifest"), :deprecated => true
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def disable_simple_content_access
       task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
@@ -124,5 +124,9 @@ module Katello
         { "pool" => pool[:id], "quantity" => pool[:quantity] } if pool
       end
     end
+
+    def deprecated
+      ::Foreman::Deprecation.api_deprecation_warning("it will be removed in Katello 4.0, Please see /api/v2/simple_content_access")
+    end
   end
 end

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

@@ -42,6 +42,16 @@ module Katello
         fail HttpErrors::NotFound, _("Could not find %{name} resource with id %{id}") % {id: id, name: name}
       end
 
+      def throw_resources_not_found(name:, expected_ids: [])
+        resources = yield
+        found_ids = resources.map(&:id)
+        missing_ids = expected_ids.map(&:to_i) - found_ids
+
+        if missing_ids.any?
+          fail HttpErrors::NotFound, _("Could not find %{name} resources with ids %{ids}") % {ids: missing_ids.join(', '), name: name}
+        end
+      end
+
       def check_association_ids
         if filtered_associations
           wrapped_params = params[self._wrapper_options.name]

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

@@ -3,37 +3,41 @@ module Katello
     module Api::V2::BulkHostsExtensions
       extend ActiveSupport::Concern
 
+      def bulk_hosts_relation(permission, org)
+        relation = ::Host::Managed.authorized(permission)
+        relation = relation.where(organization: org) if org
+        relation
+      end
+
       def find_bulk_hosts(permission, bulk_params, restrict_to = nil)
         #works on a structure of param_group bulk_params and transforms it into a list of systems
-        find_organization
         bulk_params[:included] ||= {}
         bulk_params[:excluded] ||= {}
-        @hosts = []
 
-        unless bulk_params[:included][:ids].blank?
-          @hosts = ::Host::Managed.authorized(permission).where(:id => bulk_params[:included][:ids])
-          @hosts = @hosts.where(:organization_id => @organization.id) if @organization
+        if bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
+          fail HttpErrors::BadRequest, _("No hosts have been specified.")
+        end
+
+        find_organization
+        @hosts = bulk_hosts_relation(permission, @organization)
+
+        if bulk_params[:included][:ids].present?
+          @hosts = @hosts.where(id: bulk_params[:included][:ids])
         end
 
         if bulk_params[:included][:search]
-          search_hosts = ::Host::Managed.authorized(permission)
-          search_hosts = search_hosts.where(:organization_id => @organization.id) if @organization
-          search_hosts = search_hosts.search_for(bulk_params[:included][:search])
-          if @hosts.any?
-            @hosts = ::Host.where(id: @hosts).or(::Host.where(id: search_hosts))
-          else
-            @hosts = search_hosts
-          end
+          search_hosts = bulk_hosts_relation(permission, @organization).search_for(bulk_params[:included][:search])
+          @hosts = @hosts.merge(search_hosts)
         end
 
         @hosts = restrict_to.call(@hosts) if restrict_to
-        @hosts = @hosts.where.not(id: bulk_params[:excluded][:ids]) unless bulk_params[:excluded][:ids].blank?
 
-        if bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
-          fail HttpErrors::BadRequest, _("No hosts have been specified.")
-        elsif @hosts.empty?
-          fail HttpErrors::Forbidden, _("Action unauthorized to be performed on selected hosts.")
+        if bulk_params[:excluded][:ids].present?
+          @hosts = @hosts.where.not(id: bulk_params[:excluded][:ids])
         end
+
+        fail HttpErrors::Forbidden, _("Action unauthorized to be performed on selected hosts.") if @hosts.empty?
+
         @hosts
       end
 

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

@@ -107,7 +107,7 @@ module Katello
       true
     end
 
-    def authorize_remove_environments(view, options)
+    def authorize_remove_environments(view, options) # rubocop:disable Metrics/CyclomaticComplexity
       env_ids = options[:environment_ids]
 
       return true if env_ids.blank?

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

@@ -0,0 +1,16 @@
+module Katello
+  module Concerns
+    module RegistrationControllerExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :format_activation_key, only: [:create]
+      end
+
+      def format_activation_key
+        return if params[:activation_key].blank?
+        params[:activation_key] = params[:activation_key].split(',').map(&:strip).reject(&:blank?).join(',')
+      end
+    end
+  end
+end

data/app/helpers/katello/sync_management_helper.rb

@@ -35,8 +35,6 @@ module Katello
     module RepoMethods
       # returns all repos in hash representation with minors and arch children included
       def collect_repos(products, env, include_feedless = true)
-        Glue::Pulp::Repos.prepopulate! products, env, []
-
         products.map do |prod|
           minor_repos, repos_without_minor = collect_minor(prod.repos(env, nil, include_feedless))
           { :name => prod.name, :object => prod, :id => prod.id, :type => "product", :repos => repos_without_minor,

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

@@ -13,7 +13,7 @@ module Actions
           ::Katello::Resources::Candlepin::Environment.create(input['organization_label'],
                                                    input['cp_id'],
                                                    input['name'],
-                                                   input['description'])
+                                                   input['description'].try(:truncate, 255))
         end
       end
     end

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

@@ -9,7 +9,7 @@ module Actions
                     :new_content_id => new_content_id)
         end
 
-        def finalize
+        def finalize # rubocop:disable Metrics/AbcSize
           content_view = ::Katello::ContentView.find(input[:content_view_id])
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           content_ids = content_view.repos(environment).map(&:content_id).uniq.compact