katello 3.6.0.1.rc2 → 3.7.0.rc1

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

@@ -2,6 +2,11 @@ module Katello
   class Api::V2::RepositoriesController < Api::V2::ApiController # rubocop:disable Metrics/ClassLength
     include Katello::Concerns::FilteredAutoCompleteSearch
 
+    CONTENT_CREDENTIAL_GPG_KEY_TYPE = "gpg_key".freeze
+    CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE = "ssl_ca_cert".freeze
+    CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE = "ssl_client_cert".freeze
+    CONTENT_CREDENTIAL_SSL_CLIENT_KEY_TYPE = "ssl_client_key".freeze
+
     before_action :find_optional_organization, :only => [:index, :auto_complete_search]
     before_action :find_product, :only => [:index, :auto_complete_search]
     before_action :find_product_for_create, :only => [:create]
@@ -11,7 +16,10 @@ module Katello
                                               :import_uploads, :gpg_key_content]
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
-    before_action :find_gpg_key, :only => [:create, :update]
+    before_action :only => [:create, :update] { find_content_credential CONTENT_CREDENTIAL_GPG_KEY_TYPE }
+    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 :error_on_rh_product, :only => [:create]
     before_action :error_on_rh_repo, :only => [:destroy]
 
@@ -21,6 +29,9 @@ module Katello
     def_param_group :repo do
       param :url, String, :desc => N_("repository source url")
       param :gpg_key_id, :number, :desc => N_("id of the gpg key that will be assigned to the new repository")
+      param :ssl_ca_cert_id, :number, :desc => N_("Idenifier of the SSL CA Cert")
+      param :ssl_client_cert_id, :number, :desc => N_("Identifier of the SSL Client Cert")
+      param :ssl_client_key_id, :number, :desc => N_("Identifier of the SSL Client Key")
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
       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")
@@ -35,6 +46,7 @@ module Katello
       param :deb_components, String, :desc => N_("comma separated list of repo components to be synched from deb-archive")
       param :deb_architectures, String, :desc => N_("comma separated list of architectures to be synched from deb-archive")
       param :ignore_global_proxy, :bool, :desc => N_("if true, will ignore the globally configured proxy when syncing.")
+      param :ignorable_content, Array, :desc => N_("List of content units to ignore while syncing a yum repository. Must be subset of %s") % Repository::IGNORABLE_CONTENT_UNIT_TYPES.join(",")
     end
 
     def_param_group :repo_create do
@@ -65,8 +77,28 @@ module Katello
           :required => false
     param_group :search, Api::V2::ApiController
     def index
+      base_args = [index_relation.distinct, :name, :asc]
       options = {:includes => [:gpg_key, :product, :environment]}
-      respond(:collection => scoped_search(index_relation.distinct, :name, :asc, options))
+
+      respond_to do |format|
+        format.csv do
+          options[:csv] = true
+          repos = scoped_search(*base_args, options)
+          csv_response(repos,
+                       [:id, :name, :label, :content_type, :arch, :url, :major, :minor,
+                        :cp_label, :content_label, :pulp_id, :container_repository_name,
+                        :download_policy, 'relative_path', 'product.id', 'product.name',
+                        'environment_id'],
+                       ['Id', 'Name', 'label', 'Content Type', 'Arch', 'Url', 'Major', 'Minor',
+                        'Candlepin Label', 'Content Label', 'Pulp Id', 'Container Repository Name',
+                        'Download Policy', 'Relative Path', 'Product Id', 'Product Name',
+                        'Environment Id'])
+        end
+        format.any do
+          repos = scoped_search(*base_args, options)
+          respond(:collection => repos)
+        end
+      end
     end
 
     def index_relation
@@ -142,38 +174,28 @@ module Katello
     param :name, String, :required => true
     param_group :repo_create
     param_group :repo
-    def create # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
+    def create
       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
       end
 
-      gpg_key = @product.gpg_key
-      unless repo_params[:gpg_key_id].blank?
-        gpg_key = @gpg_key
-      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)
+      ssl_client_key = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CLIENT_KEY_TYPE)
+
       repo_params[:label] = labelize_params(repo_params)
       repo_params[:arch] = repo_params[:arch] || 'noarch'
       repo_params[:url] = nil if repo_params[:url].blank?
       repo_params[:unprotected] = repo_params.key?(:unprotected) ? repo_params[:unprotected] : true
       repo_params[:gpg_key] = gpg_key
-      repository = @product.add_repo(Hash[repo_params.slice(:label, :name, :url, :content_type, :arch, :unprotected, :gpg_key, :checksum_type, :download_policy).to_h.map { |k, v| [k.to_sym, v] }])
-      repository.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
-      repository.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
-      repository.ignore_global_proxy = ::Foreman::Cast.to_bool(repo_params[:ignore_global_proxy]) if repo_params.key?(:ignore_global_proxy)
-      repository.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
-      repository.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
-      repository.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
-      if repository.ostree?
-        repository.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]
-        repository.ostree_upstream_sync_depth = repo_params[:ostree_upstream_sync_depth]
-      end
-      if repository.deb?
-        repository.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
-        repository.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
-        repository.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
-      end
+      repo_params[:ssl_ca_cert] = ssl_ca_cert
+      repo_params[:ssl_client_cert] = ssl_client_cert
+      repo_params[:ssl_client_key] = ssl_client_key
+
+      repository = construct_repo_from_params(repo_params)
       sync_task(::Actions::Katello::Repository::Create, repository, false, true)
       repository = Repository.find(repository.id)
       respond_for_show(:resource => repository)
@@ -248,6 +270,8 @@ module Katello
 
       fail HttpErrors::BadRequest, _("Repository content type must be 'yum' to export.") unless @repository.content_type == 'yum'
 
+      fail HttpErrors::BadRequest, _("On demand repositories cannot be exported.") if @repository.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+
       task = async_task(::Actions::Katello::Repository::Export, [@repository],
                         ::Foreman::Cast.to_bool(params[:export_to_iso]),
                         params[:since].try(:to_datetime),
@@ -319,7 +343,7 @@ module Katello
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :content, File, :required => true, :desc => N_("Content files to upload. Can be a single file or array of files.")
     def upload_content
-      fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Docker content.") if @repository.docker?
+      fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Container Image content.") if @repository.docker?
 
       filepaths = Array.wrap(params[:content]).compact.collect do |content|
         {path: content.path, filename: content.original_filename}
@@ -351,7 +375,8 @@ module Katello
       param 'id', String, :required => true
       param 'size', String
       param 'checksum', String
-      param 'name', String, :desc => N_("Needs to only be set for file repositories")
+      param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags")
+      param 'digest', String, :desc => N_("Needs to only be set for docker tags")
     end
     def import_uploads
       generate_metadata = ::Foreman::Cast.to_bool(params.fetch(:publish_repository, true))
@@ -362,7 +387,7 @@ module Katello
       end
 
       uploads = (params[:uploads] || []).map do |upload|
-        upload.permit(:id, :size, :checksum, :name).to_h
+        upload.permit(:id, :size, :checksum, :name, :digest).to_h
       end
 
       if params.key?(:upload_ids)
@@ -372,16 +397,18 @@ module Katello
 
       upload_ids = uploads.map { |upload| upload['id'] }
       unit_keys = uploads.map do |upload|
-        if @repository.file?
+        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_keys => unit_keys,
+                    @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)
       rescue => e
@@ -417,25 +444,67 @@ module Katello
       @repository = Repository.find(params[:id])
     end
 
-    def find_gpg_key
-      if params[:gpg_key_id]
-        @gpg_key = GpgKey.readable.where(:id => params[:gpg_key_id], :organization_id => @organization).first
-        fail HttpErrors::NotFound, _("Couldn't find gpg key '%s'") % params[:gpg_key_id] if @gpg_key.nil?
+    def find_content_credential(content_type)
+      credential_id = "#{content_type}_id".to_sym
+      credential_var = "@#{content_type}"
+
+      if params[credential_id]
+        credential_value = GpgKey.readable.where(:id => params[credential_id], :organization_id => @organization).first
+        instance_variable_set(credential_var, credential_value)
+        if instance_variable_get(credential_var).nil?
+          fail HttpErrors::NotFound, _("Couldn't find %{content_type} with id '%{id}'") % { :content_type => content_type, :id => params[credential_id] }
+        end
       end
     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,
-              :deb_releases, :deb_components, :deb_architectures
+              :deb_releases, :deb_components, :deb_architectures, {:ignorable_content => []}
              ]
+
       keys += [:label, :content_type] if params[:action] == "create"
       if params[:action] == 'create' || @repository.custom?
-        keys += [:url, :gpg_key_id, :unprotected, :name, :checksum_type, :docker_upstream_name]
+        keys += [:url, :gpg_key_id, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :unprotected, :name, :checksum_type, :docker_upstream_name]
       end
       params.require(:repository).permit(*keys).to_h
     end
 
+    def get_content_credential(repo_params, content_type)
+      credential_value = @product.send(content_type)
+
+      unless repo_params["#{content_type}_id".to_sym].blank?
+        credential_value = instance_variable_get("@#{content_type}")
+      end
+
+      credential_value
+    end
+
+    def construct_repo_from_params(repo_params)
+      repository = @product.add_repo(Hash[repo_params.slice(:label, :name, :url, :content_type, :arch, :unprotected,
+                                                            :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
+                                                            :checksum_type, :download_policy).to_h.map { |k, v| [k.to_sym, v] }])
+      repository.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
+      repository.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
+      repository.ignore_global_proxy = ::Foreman::Cast.to_bool(repo_params[:ignore_global_proxy]) if repo_params.key?(:ignore_global_proxy)
+      repository.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
+      repository.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
+      repository.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
+      repository.ignorable_content = repo_params[:ignorable_content] if repository.yum? && repo_params.key?(:ignorable_content)
+
+      if repository.ostree?
+        repository.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]
+        repository.ostree_upstream_sync_depth = repo_params[:ostree_upstream_sync_depth]
+      end
+      if repository.deb?
+        repository.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
+        repository.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
+        repository.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
+      end
+
+      repository
+    end
+
     def error_on_rh_product
       fail HttpErrors::BadRequest, _("Red Hat products cannot be manipulated.") if @product.redhat?
     end

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

@@ -2,10 +2,12 @@ module Katello
   class Api::V2::RepositorySetsController < Api::V2::ApiController
     respond_to :json
 
-    before_action :find_product, :except => [:index]
-    before_action :find_optional_product, :only => [:index]
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_action :find_product, :except => [:index, :auto_complete_search]
+    before_action :find_product_or_organization, :only => [:index, :auto_complete_search]
     before_action :custom_product?
-    before_action :find_product_content, :except => [:index]
+    before_action :find_product_content, :except => [:index, :auto_complete_search]
 
     resource_description do
       api_version "v2"
@@ -38,7 +40,7 @@ module Katello
       repos = repos.select do |repo|
         if repo[:path].include?('kickstart')
           variants = ['Server', 'Client', 'ComputeNode', 'Workstation']
-          has_variant = variants.any? { |v| repo[:substitutions][:releasever].include?(v) }
+          has_variant = variants.any? { |v| repo[:substitutions][:releasever].try(:include?, v) }
           has_variant ? repo[:enabled] : true
         else
           true
@@ -73,22 +75,26 @@ module Katello
       respond_for_async :resource => task
     end
 
-    private
+    protected
+
+    def resource_class
+      Katello::Content
+    end
 
     def default_sort
-      lambda { |relation| relation.joins(:content).order("name asc") }
+      lambda { |relation| relation.order("#{Katello::Content.table_name}.name asc") }
     end
 
     def index_relation
       if @product.nil?
-        relation = @organization.enabled_product_content
+        relation = @organization.product_contents.displayable
       else
         relation = @product.displayable_product_contents
       end
 
       relation = relation.enabled(@organization) if ::Foreman::Cast.to_bool(params[:enabled])
-      relation = relation.joins(:content).where(:name => params[:name]) if params[:name].present?
-      relation
+      relation = relation.where(Katello::Content.table_name => {:name => params[:name]}) if params[:name].present?
+      relation.redhat
     end
 
     def find_product_content
@@ -96,15 +102,16 @@ module Katello
       fail HttpErrors::NotFound, _("Couldn't find repository set with id '%s'.") % params[:id] if @product_content.nil?
     end
 
-    def find_optional_product
-      @product = Product.find_by(:id => params[:product_id])
-      @organization = @product.organization unless @product.nil?
-      find_organization if @organization.nil?
-      @product
+    def find_product_or_organization
+      if params[:product_id]
+        find_product
+      else
+        @organization = find_organization
+      end
     end
 
     def find_product
-      @product = find_optional_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
     end

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

@@ -7,6 +7,7 @@ module Katello
     before_action :find_optional_organization, :only => [:index, :available, :show]
     before_action :find_organization, :only => [:upload, :delete_manifest,
                                                 :refresh_manifest, :manifest_history]
+    before_action :check_disconnected, only: [:refresh_manifest]
     before_action :find_provider
     before_action :deprecated, :only => [:create, :destroy]
 
@@ -29,15 +30,38 @@ module Katello
     param :match_installed, :bool, :desc => N_("Return subscriptions that match installed products of the specified host")
     param :no_overlap, :bool, :desc => N_("Return subscriptions which do not overlap with a currently-attached subscription")
     def index
-      collection = scoped_search(
-        index_relation.distinct, :cp_id, :asc, resource_class: Pool, includes: [:subscription])
-      if params[:activation_key_id]
-        key_pools = @activation_key.get_key_pools
-        collection[:results] = collection[:results].map do |pool|
-          ActivationKeySubscriptionsPresenter.new(pool, key_pools)
+      options = { resource_class: Pool, includes: [:subscription], custom_sort: name_sort }
+      base_args = [index_relation.distinct, nil, nil]
+
+      respond_to do |format|
+        format.csv do
+          options[:csv] = true
+          collection = scoped_search(*base_args, options)
+          csv_response(collection,
+                       [:id, :subscription_id, :name, :cp_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, :virt_who, :upstream?],
+                       ['Pool Id', 'Subscription Id', 'Name', 'Candlepin 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'])
+        end
+        format.any do
+          collection = scoped_search(*base_args, options)
+          if params[:activation_key_id]
+            key_pools = @activation_key.get_key_pools
+            collection[:results] = collection[:results].map do |pool|
+              ActivationKeySubscriptionsPresenter.new(pool, key_pools)
+            end
+          end
+          respond(:collection => collection)
         end
       end
-      respond(:collection => collection)
+    end
+
+    def name_sort
+      lambda { |relation| relation.order("katello_subscriptions.name ASC") }
     end
 
     def index_relation

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

@@ -0,0 +1,93 @@
+module Katello
+  class Api::V2::UpstreamSubscriptionsController < Api::V2::ApiController
+    before_action :check_disconnected
+
+    resource_description do
+      description "Red Hat subscriptions management platform."
+      api_version 'v2'
+    end
+
+    def_param_group :cp_search do
+      param :page, :number, :desc => N_("Page number, starting at 1")
+      param :per_page, :number, :desc => N_("Number of results per page to return.")
+      param :order, String, :desc => N_("The order to sort the results in. ['asc', 'desc'] Defaults to 'desc'.")
+      param :sort_by, String, :desc => N_("The field to sort the data by. Defaults to the created date.")
+    end
+
+    api :GET, "/organizations/:organization_id/upstream_subscriptions",
+      N_("List available subscriptions from Red Hat Subscription Management")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    param_group :cp_search
+    param :pool_ids, Array, desc: N_("Return only the upstream pools which map to the given local pool IDs")
+    param :quantities_only, :bool, desc: N_("Only returns id and quantity fields")
+    param :attachable, :bool, desc: N_("Return only subscriptions which can be attached to the upstream allocation")
+    def index
+      index_params = upstream_pool_params
+      pools = UpstreamPool.fetch_pools(index_params)
+      page = index_params[:page] || 1
+
+      collection = scoped_search_results(
+        pools[:pools], pools[:subtotal], pools[:total], page, index_params[:per_page], nil)
+      respond(collection: collection)
+    end
+
+    api :PUT, "/organizations/:organization_id/upstream_subscriptions",
+      N_("Update the quantity of one or more subscriptions on an upstream allocation")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    param :pools, Array, desc: N_("Array of Pools to be updated. Only pools originating upstream are accepted."), required: true do
+      param :id, String, desc: N_("ID of local pool to update"), required: true
+      param :quantity, Integer, desc: N_("Desired quantity of the pool"), required: true
+    end
+    def update
+      task = async_task(::Actions::Katello::UpstreamSubscriptions::UpdateEntitlements, update_params)
+      respond_for_async :resource => task
+    end
+
+    api :DELETE, "/organizations/:organization_id/upstream_subscriptions",
+      N_("Remove one or more subscriptions from an upstream subscription allocation")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    param :pool_ids, Array, desc: N_("Array of local pool IDs. Only pools originating upstream are accepted."), required: true
+    def destroy
+      task = async_task(::Actions::Katello::UpstreamSubscriptions::RemoveEntitlements, params[:pool_ids])
+      respond_for_async :resource => task
+    end
+
+    api :POST, "/organizations/:organization_id/upstream_subscriptions",
+      N_("Add subscriptions consumed by a manifest from Red Hat Subscription Management")
+    param :pools, Array, desc: N_("Array of pools to add"), required: true do
+      param :id, String, desc: N_("Pool ID"), required: true
+      param :quantity, :number, desc: N_("Quantity of entitlements to bind"), required: true
+    end
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def create
+      task = async_task(::Actions::Katello::UpstreamSubscriptions::BindEntitlements,
+                        bind_entitlements_params)
+      respond_for_async resource: task
+    end
+
+    private
+
+    def update_params
+      params.permit(pools: [:id, :quantity])[:pools].map(&:to_h)
+    end
+
+    def upstream_pool_params
+      upstream_params = params.permit(:page, :per_page, :order, :sort_by, :quantities_only, :attachable, pool_ids: []).to_h
+
+      if params[:full_result]
+        upstream_params.delete(:per_page)
+        upstream_params.delete(:page)
+      elsif !params[:per_page]
+        upstream_params[:per_page] = Setting[:entries_per_page]
+      end
+
+      upstream_params
+    end
+
+    def bind_entitlements_params
+      params.permit(pools: [:id, :quantity])[:pools].map do |pool|
+        { "pool" => pool[:id], "quantity" => pool[:quantity] } if pool
+      end
+    end
+  end
+end