katello 3.8.1 → 3.9.0.rc1

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

@@ -5,9 +5,9 @@ module Actions
       middleware.use Actions::Middleware::PulpServicesCheck
 
       def pulp_resources(capsule_id = nil)
-        capsule_id ||= input["capsule_id"]
+        capsule_id ||= input.try(:[], "capsule_id")
         if capsule_id
-          capsule_content = ::Katello::CapsuleContent.new(SmartProxy.unscoped.find(capsule_id))
+          capsule_content = ::Katello::CapsuleContent.new(smart_proxy(capsule_id))
           capsule_content.pulp_server.resources
         else
           ::Katello.pulp_server.resources
@@ -23,6 +23,11 @@ module Actions
           ::Katello.pulp_server.extensions
         end
       end
+
+      def smart_proxy(capsule_id = nil)
+        smart_proxy = capsule_id ? SmartProxy.unscoped.find(capsule_id) : SmartProxy.default_capsule
+        smart_proxy
+      end
     end
   end
 end

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

@@ -102,6 +102,7 @@ module Actions
       private
 
       def external_task=(external_task_data)
+        external_task_data = [] if external_task_data.nil?
         external_task_data = [external_task_data] if external_task_data.is_a?(Hash)
 
         new_tasks = []

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

@@ -12,6 +12,7 @@ module Actions
               pulp_resources.consumer.regenerate_applicability_by_id(input[:uuids].first)
             rescue RestClient::ResourceNotFound
               Rails.logger.warn("Pulp consumer %s not found." % input[:uuids].first)
+              nil
             end
           else
             pulp_extensions.consumer.regenerate_applicability_by_ids(input[:uuids])

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

@@ -0,0 +1,11 @@
+module Actions
+  module Pulp
+    module Repository
+      class CopyModuleDefault < Pulp::Repository::AbstractCopyContent
+        def content_extension
+          pulp_extensions.module_default
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Actions
+  module Pulp
+    module Repository
+      class CopyModuleStream < Pulp::Repository::AbstractCopyContent
+        def content_extension
+          pulp_extensions.module
+        end
+      end
+    end
+  end
+end

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

@@ -17,6 +17,7 @@ module Actions
           param :path
           param :with_importer
           param :docker_upstream_name
+          param :docker_tags_whitelist
           param :download_policy
           param :capsule_id
           param :mirror_on_sync
@@ -112,6 +113,7 @@ module Actions
           importer = Runcible::Models::DockerImporter.new
           importer.proxy_host      = input[:proxy_host]
           importer.upstream_name   = input[:docker_upstream_name] if input[:docker_upstream_name]
+          importer.tags            = input[:docker_tags_whitelist] if input[:docker_tags_whitelist]
           importer.feed            = input[:feed]
           importer.enable_v1       = false
           importer.ssl_validation  = input[:ssl_validation]

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

@@ -28,10 +28,11 @@ module Actions
         end
 
         def distributor_config
+          input[:override_config] ||= {}
           # the check for YumCloneDistributor is here for backwards compatibility
           if input[:distributor_type_id] == Runcible::Models::YumCloneDistributor.type_id
-            { override_config: { source_repo_id: input[:source_pulp_id],
-                                 source_distributor_id: source_distributor_id} }
+            { override_config: input[:override_config].merge(source_repo_id: input[:source_pulp_id],
+                                                               source_distributor_id: source_distributor_id) }
           else
             { override_config: input[:override_config] }
           end

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

@@ -0,0 +1,11 @@
+module Actions
+  module Pulp
+    module Repository
+      class RemoveModuleDefault < Pulp::Repository::AbstractRemoveContent
+        def content_extension
+          pulp_extensions.module_default
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Actions
+  module Pulp
+    module Repository
+      class RemoveModuleStream < Pulp::Repository::AbstractRemoveContent
+        def content_extension
+          pulp_extensions.module
+        end
+      end
+    end
+  end
+end

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

@@ -16,25 +16,12 @@ module Actions
             # don't initiate, just load the existing task
             task_resource.poll(input[:task_id])
           else
-            sync_options = {}
-
-            if SETTINGS[:katello][:pulp][:sync_KBlimit]
-              # set bandwidth limit
-              sync_options[:max_speed] ||= SETTINGS[:katello][:pulp][:sync_KBlimit]
-            end
-            if SETTINGS[:katello][:pulp][:sync_threads]
-              # set threads per sync
-              sync_options[:num_threads] ||= SETTINGS[:katello][:pulp][:sync_threads]
-            end
-
-            sync_options[:feed] = input[:source_url] if input[:source_url]
-            sync_options[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
-
-            sync_options.merge!(input[:options]) if input[:options]
-
-            output[:pulp_tasks] = pulp_tasks =
-                                    [pulp_resources.repository.sync(input[:pulp_id], override_config: sync_options)]
-
+            overrides = {}
+            overrides[:feed] = input[:source_url] if input[:source_url]
+            overrides[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
+            overrides[:options] = input[:options] if input[:options]
+            repo = ::Katello::Repository.find_by(:pulp_id => input[:pulp_id])
+            output[:pulp_tasks] = pulp_tasks = ::Katello::Pulp::Repository.new(repo, smart_proxy(input[:capsule_id])).sync(overrides)
             pulp_tasks
           end
         end

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

@@ -1,7 +1,7 @@
 module Actions
   module Pulp
     module Repository
-      class UpdateImporter < Pulp::Abstract
+      class UpdateImporter < Pulp::AbstractAsyncTask
         input_format do
           param :repo_id
           param :id
@@ -9,17 +9,19 @@ module Actions
           param :capsule_id
         end
 
-        def run
+        def invoke_external_task
           # Update ssl options by themselves workaround for https://pulp.plan.io/issues/2727
           ssl_ca_cert = input[:config].delete('ssl_ca_cert')
           ssl_client_cert = input[:config].delete('ssl_client_cert')
           ssl_client_key = input[:config].delete('ssl_client_key')
 
-          output[:response] = pulp_resources.repository.
-                                     update_importer(input[:repo_id], input[:id], :ssl_client_cert => ssl_client_cert,
-                                                     :ssl_client_key => ssl_client_key, :ssl_ca_cert => ssl_ca_cert)
-          output[:response] = pulp_resources.repository.
-              update_importer(*input.values_at(:repo_id, :id, :config))
+          # map both "" and nil to nil. Pulp does not treat "" as None.
+          input[:config]['basic_auth_username'] = nil if input[:config]['basic_auth_username'].blank?
+          input[:config]['basic_auth_password'] = nil if input[:config]['basic_auth_password'].blank?
+
+          pulp_resources.repository.update_importer(input[:repo_id], input[:id], :ssl_client_cert => ssl_client_cert,
+                                                    :ssl_client_key => ssl_client_key, :ssl_ca_cert => ssl_ca_cert)
+          pulp_resources.repository.update_importer(*input.values_at(:repo_id, :id, :config))
         end
 
         def run_progress_weight

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -0,0 +1,42 @@
+module Katello
+  module Concerns
+    module BaseTemplateScopeExtensions
+      extend ActiveSupport::Concern
+
+      module Overrides
+        def allowed_helpers
+          super + [:errata, :host_subscriptions, :host_applicable_errata_ids, :host_applicable_errata_filtered,
+                   :host_latest_applicable_rpm_version, :load_pools]
+        end
+      end
+
+      included do
+        prepend Overrides
+      end
+
+      def errata(id)
+        Katello::Erratum.in_repositories(Katello::Repository.readable).with_identifiers(id).map(&:attributes).first.slice!('created_at', 'updated_at')
+      end
+
+      def host_subscriptions(host)
+        host.subscriptions
+      end
+
+      def host_applicable_errata_ids(host)
+        host.applicable_errata.map(&:errata_id)
+      end
+
+      def host_applicable_errata_filtered(host, filter = '')
+        host.applicable_errata.search_for(filter)
+      end
+
+      def host_latest_applicable_rpm_version(host, package)
+        host.applicable_rpms.where(name: package).order(:version_sortable).limit(1).pluck(:nvra).first
+      end
+
+      def load_pools(search: '', includes: nil)
+        load_resource(klass: Pool.readable, search: search, permission: nil, includes: includes)
+      end
+    end
+  end
+end

data/app/lib/katello/concerns/renderer_extensions.rb

@@ -7,10 +7,12 @@ module Katello
         def kickstart_attributes
           super
 
-          content_view = @host.try(:content_facet).try(:content_view) || @host.try(:content_view)
-          if content_view && @host.operatingsystem.is_a?(Redhat) &&
-                  @host.operatingsystem.kickstart_repos(@host).first.present?
-            @mediapath ||= @host.operatingsystem.mediumpath(@host)
+          medium_provider = Katello::ManagedContentMediumProvider.new(host.content_facet)
+          content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
+
+          if content_view && host.operatingsystem.is_a?(Redhat) &&
+                  host.operatingsystem.kickstart_repos(host).first.present?
+            @mediapath ||= host.operatingsystem.mediumpath(medium_provider)
           end
         end
       end

data/app/lib/katello/http_resource.rb

@@ -201,7 +201,11 @@ module Katello
       def hash_to_query(query_parameters)
         query_parameters.inject("?") do |so_far, current|
           so_far << "&" unless so_far == "?"
-          so_far << "#{current[0].to_s}=#{url_encode(current[1])}"
+          if current[1].is_a?(Array)
+            so_far << current[1].map { |attr| "#{current[0]}=#{attr}" }.join('&')
+          else
+            so_far << "#{current[0].to_s}=#{url_encode(current[1])}"
+          end
         end
       end
     end

data/app/lib/katello/repo_discovery.rb

@@ -2,16 +2,19 @@ module Katello
   class RepoDiscovery
     attr_reader :found, :crawled, :to_follow
 
-    def initialize(url, content_type = 'yum', upstream_username = nil, upstream_password = nil, proxy = {}, crawled = [], found = [], to_follow = [])
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(url, content_type = 'yum', upstream_username = nil, upstream_password = nil, search = '*', proxy = {}, crawled = [], found = [], to_follow = [])
       @uri = uri(url)
       @content_type = content_type
       @upstream_username = upstream_username.empty? ? nil : upstream_username
       @upstream_password = upstream_password.empty? ? nil : upstream_password
+      @search = search
       @found = found
       @crawled = crawled
       @to_follow = to_follow
       @proxy = proxy
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def uri(url)
       #add a / on the end, as directories require it or else
@@ -43,11 +46,12 @@ module Katello
       params[:user] = @upstream_username unless @upstream_username.empty?
       params[:password] = @upstream_password unless @upstream_password.empty?
       begin
-        results = RestClient.get(@uri.to_s + "v1/search?q=*", params)
+        results = RestClient.get(@uri.to_s + "v1/search?q=#{@search}", params)
         JSON.parse(results)['results'].each do |result|
           @found << result['name']
         end
       rescue
+        # Note: v2 endpoint does not support search
         results = RestClient.get(@uri.to_s + "v2/_catalog", params)
         @found = JSON.parse(results)['repositories']
       end

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

@@ -4,6 +4,8 @@ module Katello
       class Consumer < CandlepinResource
         extend ConsumerResource
 
+        GET_PARAM_BATCH_SIZE = 75
+
         class << self
           def all_uuids
             cp_consumers = Organization.all.map do |org|
@@ -25,6 +27,14 @@ module Katello
             end
           end
 
+          def get_all(uuids)
+            consumers = []
+            uuids.each_slice(GET_PARAM_BATCH_SIZE) do |slice|
+              consumers += get(:uuid => slice)
+            end
+            consumers
+          end
+
           def create(env_id, parameters, activation_key_cp_ids)
             parameters['installedProducts'] ||= [] #if installed products is nil, candlepin won't attach custom products
             url = "/candlepin/environments/#{url_encode(env_id)}/consumers/"
@@ -75,7 +85,7 @@ module Katello
           end
 
           def available_pools(owner_label, uuid, listall = false)
-            url = Pool.path(nil, owner_label) + "?consumer=#{uuid}&listall=#{listall}&add_future=true"
+            url = Resources::Candlepin::Pool.path(nil, owner_label) + "?consumer=#{uuid}&listall=#{listall}&add_future=true"
             response = Candlepin::CandlepinResource.get(url, self.default_headers).body
             JSON.parse(response)
           end
@@ -157,6 +167,13 @@ module Katello
             end
           end
 
+          def purpose_compliance(uuid)
+            response = Candlepin::CandlepinResource.get(join_path(path(uuid), 'purpose_compliance'), self.default_headers(uuid)).body
+            if response.present?
+              JSON.parse(response).with_indifferent_access
+            end
+          end
+
           def events(uuid)
             response = Candlepin::CandlepinResource.get(join_path(path(uuid), 'events'), self.default_headers).body
             if response.present?

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

@@ -115,6 +115,15 @@ module Katello
             end
           end
 
+          def system_purpose(key)
+            response = Candlepin::CandlepinResource.get(join_path(path(key), 'system_purpose'), self.default_headers).body
+            if response.empty?
+              return []
+            else
+              JSON.parse(response)['systemPurposeAttributes']
+            end
+          end
+
           def auto_attach(key)
             response = self.post(join_path(path(key), 'entitlements'), "", self.default_headers).body
             if response.empty?

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

@@ -28,8 +28,8 @@ module Katello
             self.delete(path(id), self.default_headers).code.to_i
           end
 
-          def entitlements(pool_id, included = [])
-            entitlement_json = self.get("#{path(pool_id)}/entitlements?#{included_list(included)}", self.default_headers).body
+          def consumer_uuids(pool_id)
+            entitlement_json = self.get("#{path(pool_id)}/entitlements/consumer_uuids", self.default_headers).body
             JSON.parse(entitlement_json)
           end
         end

data/app/lib/katello/validators/root_repository_unique_attribute_validator.rb

@@ -0,0 +1,13 @@
+module Katello
+  module Validators
+    class RootRepositoryUniqueAttributeValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        exists = RootRepository.where(attribute => value).where("id != ?", record.id || -1).exists?
+
+        if record.send("#{attribute}_changed?") && record.custom? && exists
+          record.errors[attribute] << _("has already been taken for this product.")
+        end
+      end
+    end
+  end
+end

data/app/models/katello/authorization/product.rb

@@ -50,10 +50,9 @@ module Katello
             query = query.where(:id => repo_ids)
           end
 
-          query.joins(:product)
-               .joins(:content_view_version)
-               .where("#{Katello::ContentViewVersion.table_name}.content_view_id" => Katello::ContentView.default.pluck(:id))
-               .where(:product_id => Katello::Product.readable.pluck(:id))
+          query.joins(:content_view_version)
+               .where("#{::Katello::ContentViewVersion.table_name}.content_view_id" => Katello::ContentView.default.pluck(:id))
+               .in_product(::Katello::Product.readable)
         end
 
         def syncable?

data/app/models/katello/authorization/repository.rb

@@ -20,19 +20,19 @@ module Katello
 
     module ClassMethods
       def readable
-        in_products = Repository.where(:product_id => Katello::Product.authorized(:view_products)).select(:id)
+        in_products = Repository.in_product(Katello::Product.authorized(:view_products)).select(:id)
         in_environments = Repository.where(:environment_id => Katello::KTEnvironment.authorized(:view_lifecycle_environments)).select(:id)
         in_content_views = Repository.joins(:content_view_repositories).where("#{ContentViewRepository.table_name}.content_view_id" => Katello::ContentView.readable).select(:id)
         in_versions = Repository.joins(:content_view_version).where("#{Katello::ContentViewVersion.table_name}.content_view_id" => Katello::ContentView.readable).select(:id)
-        where("#{self.table_name}.id in (?) or #{self.table_name}.id in (?) or #{self.table_name}.id in (?) or #{self.table_name}.id in (?)", in_products, in_content_views, in_versions, in_environments)
+        joins(:root).where("#{Repository.table_name}.id in (?) or #{self.table_name}.id in (?) or #{self.table_name}.id in (?) or #{self.table_name}.id in (?)", in_products, in_content_views, in_versions, in_environments)
       end
 
       def deletable
-        where(:product_id => Katello::Product.authorized(:destroy_products))
+        in_product(Katello::Product.authorized(:destroy_products))
       end
 
       def syncable
-        where(:product_id => Katello::Product.authorized(:sync_products))
+        in_product(Katello::Product.authorized(:sync_products))
       end
     end
   end

data/app/models/katello/candlepin/repository_mapper.rb

@@ -10,51 +10,37 @@ module Katello
       end
 
       def find_repository
-        ::Katello::Repository.where(product_id: product.id,
+        root = ::Katello::RootRepository.where(product_id: product.id,
                                     content_id: content.cp_content_id,
-                                    environment_id: product.organization.library.id,
                                     minor: minor,
                                     arch: arch).first
+        if root
+          Katello::Repository.where(root: root,
+                                    environment_id: product.organization.library.id).first
+
+        end
       end
 
       def build_repository
-        certificate_and_key = get_certificate_and_key(product, @content.modified_product_ids(product.organization))
-
-        repository = Repository.new(
-          :environment => product.organization.library,
+        root = RootRepository.new(
           :product => product,
-          :cp_label => content.label,
           :content_id => content.cp_content_id,
           :arch => arch,
           :major => major,
           :minor => minor,
-          :relative_path => relative_path,
           :name => name,
           :label => label,
           :url => feed_url,
-          :feed_ca => ::Katello::Repository.feed_ca_cert(feed_url),
-          :feed_cert => certificate_and_key[:cert],
-          :feed_key => certificate_and_key[:key],
           :content_type => katello_content_type,
-          :preserve_metadata => true, #preserve repo metadata when importing from cp
           :unprotected => unprotected?,
           :download_policy => download_policy,
-          :mirror_on_sync => true,
-          :content_view_version => product.organization.
-                                  library.default_content_view_version
+          :mirror_on_sync => true
         )
 
-        repository
-      end
-
-      def get_certificate_and_key(product, modified_product_ids = [])
-        modified_product_ids.each do |modified_product_id|
-          modified_product = Product.where(:cp_id => modified_product_id).first
-          product = modified_product if modified_product &&
-                                        modified_product.certificate &&
-                                        modified_product.key
-        end
-        {:cert => product.certificate, :key => product.key}
+        Repository.new(:root => root,
+                       :relative_path => relative_path,
+                       :environment => product.organization.library,
+                       :content_view_version => product.organization.library.default_content_view_version)
       end
 
       def validate!