katello 3.13.4 → 3.14.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f766a3017d31408f1d870da14183242e914597a31783a07257a5df741330e6d
-  data.tar.gz: f0abe55e1bd1cf6148ae02eaa02ab068e49f6c3909af80624c9b578cb1f84a1f
+  metadata.gz: c1e2baddffe6d51af8dbaa2e187ada9d5be93c145a8b3bea3113b77f49592b14
+  data.tar.gz: 3b42136f2440dc5c12e17472bcaa112d21a2d9e4db649dcbfcaa8f6b847d6732
 SHA512:
-  metadata.gz: 712836c8cd4ba4a476650ad3fd04f3e04be29be3cc615c5be137d289578048f98a06ae8e2a31f6653e082f198e865df87bc608864f98aa77a2e7ebcc0d95a667
-  data.tar.gz: 0fbec392523232e91c577f7e0df9ca2080d60f828e8e9397d5c0ef6a4b2b5e7ad4d275a3a09ec92fa9c67b34a36e09305d1e57551e5c0af8d072aa00483a671b
+  metadata.gz: 179fe38f2b010e92ee61df9cec470142d2889ba0f03894eb7ac4ac4f4a96801f1e37106249dbdd3c851c2fdc7ed84b69ee001efa7f6e48c71d56c3618be1405b
+  data.tar.gz: e98d76db3da13831b995f31bc5e6332ac7942e3179e679fb95756b911d0509313e31d09922cc6242eb0889abf1cb78aec72079c2601f9d7746d839f1d34b5b9e

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

@@ -42,7 +42,7 @@ module Katello
 
     def optional_authorize
       @repository = find_scope_repository
-      if @repository && @repository.environment.registry_unauthenticated_pull
+      if @repository && (@repository.environment.registry_unauthenticated_pull || ssl_client_authorized?(@repository.organization.label))
         true
       else
         authorize
@@ -51,7 +51,7 @@ module Katello
 
     def registry_authorize
       @repository = find_readable_repository
-      return true if ['GET', 'HEAD'].include?(request.method) && @repository && @repository.environment.registry_unauthenticated_pull
+      return true if ['GET', 'HEAD'].include?(request.method) && @repository && !require_user_authorization?
 
       token = request.headers['Authorization']
       if token
@@ -79,10 +79,7 @@ module Katello
 
     def authorize_repository_write
       @repository = find_writable_repository
-      unless @repository
-        not_found params[:repository]
-        return false
-      end
+      return item_not_found(params[:repository]) unless @repository
       true
     end
 
@@ -102,26 +99,32 @@ module Katello
     def find_readable_repository
       return nil unless params[:repository]
       repository = Repository.docker_type.find_by(container_repository_name: params[:repository])
-      if repository && !repository.environment.registry_unauthenticated_pull
+      if require_user_authorization?(repository)
         repository = readable_repositories.docker_type.find_by(container_repository_name: params[:repository])
       end
       repository
     end
 
+    def require_user_authorization?(repository = @repository)
+      !repository || (!repository.environment.registry_unauthenticated_pull && !ssl_client_authorized?(repository.organization.label))
+    end
+
+    def ssl_client_authorized?(org_label)
+      request.headers['HTTP_SSL_CLIENT_VERIFY'] == "SUCCESS" && request.headers['HTTP_SSL_CLIENT_S_DN'] == "O=#{org_label}"
+    end
+
     def authorize_repository_read
       @repository = find_readable_repository
-      unless @repository
-        not_found params[:repository]
-        return false
-      end
+      return item_not_found(params[:repository]) unless @repository
 
       if params[:tag]
         if params[:tag][0..6] == 'sha256:'
           manifest = Katello::DockerManifestList.where(digest: params[:tag]).first || Katello::DockerManifest.where(digest: params[:tag]).first
-          not_found params[:tag] unless manifest
+          return item_not_found(params[:tag]) unless manifest
         else
-          tag = DockerMetaTag.where(repository_id: @repository.id, name: params[:tag]).first
-          not_found params[:tag] unless tag
+          tag = ::Katello::DockerMetaTag.where(id: ::Katello::RepositoryDockerMetaTag.
+                                    where(repository_id: @repository.id).select(:docker_meta_tag_id), name: params[:tag]).first
+          return item_not_found(params[:tag]) unless tag
         end
       end
 
@@ -129,7 +132,7 @@ module Katello
     end
 
     def token
-      if @repository && @repository.environment.registry_unauthenticated_pull
+      if !require_user_authorization?
         personal_token = OpenStruct.new(token: 'unauthenticated', issued_at: Time.now, expires_at: Time.now + 3)
       else
         personal_token = PersonalAccessToken.where(user_id: User.current.id, name: 'registry').first
@@ -312,7 +315,7 @@ module Katello
     end
 
     def catalog
-      repositories = readable_repositories.where(content_type: 'docker').collect do |repository|
+      repositories = readable_repositories.docker_type.collect do |repository|
         repository.container_repository_name
       end
       render json: { repositories: repositories }
@@ -487,5 +490,11 @@ module Katello
       ::Api::V2::BaseController.instance_method(:process_action).bind(self).call(method_name, *args)
       Rails.logger.debug "With body: #{response.body}\n" unless route_name == 'pull_blob'
     end
+
+    def item_not_found(item)
+      msg = "#{item} was not found!"
+      # returning errors based on registry specifications in https://docs.docker.com/registry/spec/api/#errors
+      render json: {errors: [code: :invalid_request, message: msg, details: msg]}, status: :not_found
+    end
   end
 end

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

@@ -37,6 +37,9 @@ module Katello
     param :content_view_id, :number, :desc => N_("content view id")
     param :max_hosts, :number, :desc => N_("maximum number of registered content hosts")
     param :unlimited_hosts, :bool, :desc => N_("can the activation key have unlimited hosts")
+    param :release_version, String, :desc => N_("content release version")
+    param :service_level, String, :desc => N_("service level")
+    param :auto_attach, :bool, :desc => N_("auto attach subscriptions upon registration")
     param :purpose_usage, String, :desc => N_("Sets the system purpose usage")
     param :purpose_role, String, :desc => N_("Sets the system purpose usage")
     param :purpose_addons, Array, :desc => N_("Sets the system add-ons")
@@ -48,6 +51,13 @@ module Katello
       end
       sync_task(::Actions::Katello::ActivationKey::Create, @activation_key)
       @activation_key.reload
+
+      sync_task(::Actions::Katello::ActivationKey::Update, @activation_key,
+                  :service_level   => activation_key_params[:service_level],
+                  :release_version => activation_key_params[:release_version],
+                  :auto_attach     => activation_key_params[:auto_attach]
+               )
+
       respond_for_create(:resource => @activation_key)
     end
 
@@ -213,36 +223,31 @@ module Katello
 
     api :PUT, "/activation_keys/:id/content_override", N_("Override content for activation_key")
     param :id, :number, :desc => N_("ID of the activation key"), :required => true
-    param :content_override, Hash, :desc => N_("Content override parameters"), :deprecated => true do
-      param :content_label, String, :desc => N_("Label of the content"), :required => true
-      param :value, String, :desc => N_("Override to a boolean value or 'default'"), :required => true
-    end
-    param :content_overrides, Array, :desc => N_("Array of Content override parameters") do
+    param :content_overrides, Array, :desc => N_("Array of Content override parameters to be added in bulk") do
       param :content_label, String, :desc => N_("Label of the content"), :required => true
       param :value, String, :desc => N_("Override value. Provide a boolean value if name is 'enabled'"), :required => false
       param :name, String, :desc => N_("Override parameter key or name. Note if name is not provided the default name will be 'enabled'"), :required => false
       param :remove, :bool, :desc => N_("Set true to remove an override and reset it to 'default'"), :required => false
     end
     def content_override
-      content_overrides = []
-      if params[:content_override]
-        ::Foreman::Deprecation.api_deprecation_warning("The parameter content_override will be removed in Katello 3.5. Please update to use the content_overrides parameter.")
-        content_override_params = {:content_label => params[:content_override][:content_label]}
-        value = params[:content_override][:value]
-        if value == "default"
-          content_override_params[:remove] = true
-        elsif value
-          content_override_params[:value] = ::Foreman::Cast.to_bool(value)
+      if params[:content_overrides]
+        organization = @activation_key.organization
+        specified_labels = []
+        content_override_values = params[:content_overrides].map do |override|
+          specified_labels << override[:content_label]
+          validate_content_overrides_enabled(override)
+        end
+        specified_labels.uniq!
+        existing_labels = organization.contents.where(label: specified_labels).uniq
+
+        unless specified_labels.size == existing_labels.size
+          missing_labels = specified_labels - existing_labels.pluck(:label)
+          msg = "Content label(s) \"#{missing_labels.join(", ")}\" were not found in the Organization \"#{organization}\""
+          fail HttpErrors::BadRequest, _(msg)
         end
-        content_overrides << content_override_params
-      elsif params[:content_overrides]
-        content_overrides = params[:content_overrides]
-      end
 
-      content_override_values = content_overrides.map do |override_params|
-        validate_content_overrides_enabled(override_params)
+        @activation_key.set_content_overrides(content_override_values)
       end
-      @activation_key.set_content_overrides(content_override_values)
       respond_for_show(:resource => @activation_key)
     end
 

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

@@ -6,6 +6,12 @@ module Katello
     apipie_concern_subst(:a_resource => N_("an ansible collection"), :resource_id => "ansible_collections")
     include Katello::Concerns::Api::V2::RepositoryContentController
 
+    def index
+      sort_by, sort_order, options = sort_options
+      options[:includes] = [:tags]
+      respond(:collection => scoped_search(index_relation, sort_by, sort_order, options))
+    end
+
     def default_sort
       %w(name asc)
     end

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

@@ -8,18 +8,24 @@ module Katello
 
     api :POST, "/repositories/:repository_id/content_uploads", N_("Create an upload request")
     param :repository_id, :number, :required => true, :desc => N_("repository id")
+    param :size, :number, :required => true, :desc => N_("Size of file to upload")
+    param :checksum, String, :required => false, :desc => N_("Checksum of file to upload")
+    param :content_type, RepositoryTypeManager.uploadable_content_types.map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'puppet_module', 'rpm', 'srpm')")
     def create
-      render :json => @repository.backend_content_service(::SmartProxy.pulp_master).create_upload
+      content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type).default_managed_content_type.label
+      unit_type_id = SmartProxy.pulp_master.content_service(content_type).content_type
+      render :json => @repository.backend_content_service(::SmartProxy.pulp_master).create_upload(params[:size], params[:checksum], unit_type_id)
     end
 
     api :PUT, "/repositories/:repository_id/content_uploads/:id", N_("Upload a chunk of the file's content")
     param :repository_id, :number, :required => true, :desc => N_("Repository id")
     param :id, String, :required => true, :desc => N_("Upload request id")
+    param :size, :number, :required => true, :desc => N_("Size of file to upload")
     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
       @repository.backend_content_service(::SmartProxy.pulp_master)
-        .upload_chunk(params[:id], params[:offset], params[:content])
+        .upload_chunk(params[:id], params[:offset], params[:content], params[:size])
       head :no_content
     end
 

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

@@ -34,6 +34,7 @@ module Katello
     param :end_date, String, :desc => N_("erratum: end date (YYYY-MM-DD)")
     param :types, Array, :desc => N_("erratum: types (enhancement, bugfix, security)")
     param :date_type, String, :desc => N_("erratum: search using the 'Issued On' or 'Updated On' column of the errata. Values are 'issued'/'updated'")
+    param :module_stream_ids, Array, :desc => N_("module stream ids")
     def create
       rule_clazz = ContentViewFilter.rule_class_for(@filter)
 
@@ -45,6 +46,12 @@ module Katello
         rule_clazz.create!(rule_params.except(:errata_ids)
           .merge(filter: @filter, errata_id: errata_id))
       end
+      if rule_params[:module_stream_ids]
+        rules += (rule_params[:module_stream_ids] || []).map do |module_stream_id|
+          rule_clazz.create!(rule_params.except(:module_stream_ids)
+            .merge(filter: @filter, module_stream_id: module_stream_id))
+        end
+      end
 
       if rules.empty?
         rules = [rule_clazz.create!(rule_params.merge(:filter => @filter))]
@@ -125,7 +132,7 @@ module Katello
       @rule_params ||= params.fetch(:content_view_filter_rule, {}).
             permit(:uuid, :version, :min_version, :max_version, :architecture,
                     :errata_id, :start_date, :end_date, :date_type,
-                    :types => [], :errata_ids => [], name: [])
+                    :types => [], :module_stream_ids => [], :errata_ids => [], name: [])
     end
 
     def process_errata_ids(select_all_params)

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

@@ -34,7 +34,7 @@ module Katello
     api :post, "/content_view_filters", N_("create a filter for a content view")
     param :content_view_id, :number, :desc => N_("content view identifier"), :required => true
     param :name, String, :desc => N_("name of the filter"), :required => true
-    param :type, String, :desc => N_("type of filter (e.g. rpm, package_group, erratum, docker)"), :required => true
+    param :type, String, :desc => N_("type of filter (e.g. rpm, package_group, erratum, docker, modulemd)"), :required => true
     param :original_packages, :bool, :desc => N_("add all packages without errata to the included/excluded list. " \
                                                        "(package filter only)")
     param :inclusion, :bool, :desc => N_("specifies if content should be included or excluded, default: inclusion=false")

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

@@ -43,7 +43,7 @@ module Katello
       collection = collection.where("#{date_type} >= ?", params[:start_date]) if params[:start_date]
       collection = collection.where("#{date_type} <= ?", params[:end_date]) if params[:end_date]
       collection = collection.of_type(params[:types]) if params[:types]
-      collection.non_modular
+      collection
     end
 
     def custom_index_relation(collection)

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

@@ -52,11 +52,11 @@ module Katello
       respond_for_index(:collection => index_response, :template => "index")
     end
 
-    api :GET, "/hosts/:host_id/subscriptions/events", N_("List subscription events for the host")
+    api :GET, "/hosts/:host_id/subscriptions/events", N_("List subscription events for the host"), :deprecated => true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     def events
-      collection = full_result_response(@host.subscription_facet.candlepin_consumer.events.map { |e| OpenStruct.new(e) })
-      respond_for_index :collection => collection
+      ::Foreman::Deprecation.api_deprecation_warning("Events API is being deprecated and will be removed in Katello 3.16.")
+      respond_for_index :collection => full_result_response([])
     end
 
     api :DELETE, "/hosts/:host_id/subscriptions/", N_("Unregister the host as a subscription consumer")

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

@@ -0,0 +1,24 @@
+module Katello
+  class Api::V2::KatelloPingController < Api::V2::ApiController
+    resource_description do
+      api_version "v2"
+      resource_id "ping"
+      api_base_url ""
+    end
+
+    skip_before_action :authorize
+    before_action :require_login, :only => [:index]
+
+    api :GET, "/katello/api/ping", N_("Shows status of Katello system and it's subcomponents")
+    description N_("This service is only available for authenticated users")
+    def index
+      respond_for_show :resource => Katello::Ping.ping
+    end
+
+    api :GET, "/katello/api/status", N_("Shows version information")
+    description N_("This service is available for unauthenticated users")
+    def server_status
+      respond_for_show :resource => Katello::Ping.status, :template => "server_status"
+    end
+  end
+end

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

@@ -35,6 +35,27 @@ module Katello
       %w(name asc)
     end
 
+    def available_for_content_view_filter(filter, _collection)
+      collection_ids = []
+      current_ids = filter.module_stream_rules.map(&:module_stream_id)
+      filter.applicable_repos.each do |repo|
+        collection_ids.concat(repo.module_stream_ids)
+      end
+      collection = ModuleStream.where(:id => collection_ids)
+      collection = collection.where("id not in (?)", current_ids) unless current_ids.empty?
+      collection
+    end
+
+    def filter_by_content_view(filter, collection)
+      repos = Katello::ContentView.find(filter.content_view_id).repositories
+      ids = repos.map { |r| r.send(:module_stream_ids) }.flatten
+      filter_by_ids(ids, collection)
+    end
+
+    def filter_by_content_view_filter(filter, collection)
+      collection.where(:id => filter.module_stream_rules.pluck(:module_stream_id))
+    end
+
     private
 
     def check_params

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

@@ -70,6 +70,11 @@ module Katello
       %w(name asc)
     end
 
+    def filter_by_content_view_filter(filter, collection)
+      ids = filter.send("#{singular_resource_name}_rules").pluck(:uuid)
+      filter_by_ids(ids, collection)
+    end
+
     private
 
     def repo_association

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

@@ -75,6 +75,22 @@ module Katello
       collection
     end
 
+    def filter_by_content_view_filter(filter, collection)
+      filtered_rpms = []
+      filter.package_rules.each do |rule|
+        filtered_rpms += filter.query_rpms_from_collection(collection, rule).pluck(:id)
+      end
+
+      collection.where(id: filter.applicable_rpms.pluck(:id) & filtered_rpms)
+    end
+
+    def filter_by_content_view_filter_rule(rule, collection)
+      filter = rule.filter
+      filtered_rpms = filter.query_rpms_from_collection(collection, rule).pluck(:id)
+
+      collection.where(id: filter.applicable_rpms.pluck(:id) & filtered_rpms)
+    end
+
     private
 
     def find_host

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

@@ -54,7 +54,7 @@ module Katello
       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"), :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_whitelist, String, :desc => N_("Name of collection to sync from URL")
+      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")
     end
@@ -90,6 +90,7 @@ module Katello
     param :description, String, :desc => N_("description of the repository")
     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_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Repository)
     def index
@@ -119,6 +120,7 @@ module Katello
 
     def index_relation
       query = Repository.readable
+      query = query.with_content(params[:with_content]) if params[:with_content]
       query = index_relation_product(query)
       query = query.with_type(params[:content_type]) if params[:content_type]
       query = query.where(:root_id => RootRepository.where(:name => params[:name])) if params[:name]
@@ -385,6 +387,7 @@ module Katello
     param :content_type, RepositoryTypeManager.uploadable_content_types.map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'puppet_module', 'rpm', 'srpm')")
     param :uploads, Array, :desc => N_("Array of uploads to import") do
       param 'id', String, :required => true
+      param 'content_unit_id', String
       param 'size', String
       param 'checksum', String
       param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags")
@@ -399,7 +402,7 @@ module Katello
       end
 
       uploads = (params[:uploads] || []).map do |upload|
-        upload.permit(:id, :size, :checksum, :name, :digest).to_h
+        upload.permit(:id, :content_unit_id, :size, :checksum, :name, :digest).to_h
       end
 
       if params.key?(:upload_ids)
@@ -466,7 +469,7 @@ module Katello
              ]
 
       keys += [{:docker_tags_whitelist => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
-      keys += [:ansible_collection_whitelist] if params[:action] == 'create' || @repository&.ansible_collection?
+      keys += [:ansible_collection_requirements] if params[:action] == 'create' || @repository&.ansible_collection?
       keys += [:label, :content_type] if params[:action] == "create"
       if params[:action] == 'create' || @repository.custom?
         keys += [:url, :gpg_key_id, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :unprotected, :name,
@@ -508,7 +511,7 @@ module Katello
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
       root.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
       root.ignorable_content = repo_params[:ignorable_content] if root.yum? && repo_params.key?(:ignorable_content)
-      root.ansible_collection_whitelist = repo_params[:ansible_collection_whitelist] if root.ansible_collection?
+      root.ansible_collection_requirements = repo_params[:ansible_collection_requirements] if root.ansible_collection?
       root.http_proxy_policy = repo_params[:http_proxy_policy] if repo_params.key?(:http_proxy_policy)
       root.http_proxy_id = repo_params[:http_proxy_id] if repo_params.key?(:http_proxy_id)
 

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

@@ -1,6 +1,6 @@
 module Katello
   class Api::V2::SrpmsController < Api::V2::ApiController
-    apipie_concern_subst(:a_resource => N_("a source repository"), :resource => "srpms")
+    apipie_concern_subst(:a_resource => N_("SRPM details"), :resource => "srpms")
     include Katello::Concerns::Api::V2::RepositoryContentController
 
     api :GET, "/srpms", N_("List srpms")