katello 3.10.2 → 3.11.0.rc1

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

@@ -1,7 +1,7 @@
 module Actions
   module Pulp
     module Repository
-      class Refresh < Pulp::AbstractAsyncTask
+      class Refresh < Pulp::Abstract
         input_format do
           param :capsule_id
           param :pulp_id
@@ -12,13 +12,9 @@ module Actions
           plan_self(:capsule_id => options[:capsule_id], :pulp_id => repository.pulp_id)
         end
 
-        def invoke_external_task
+        def run
           repo = ::Katello::Repository.find_by(:pulp_id => input[:pulp_id])
-          if repo.nil?
-            repo = ::Katello::ContentViewPuppetEnvironment.find_by(:pulp_id => input[:pulp_id])
-            repo = repo.nonpersisted_repository
-          end
-          repo.backend_service(smart_proxy(input[:capsule_id])).refresh
+          output[:results] = repo.backend_service(smart_proxy(input[:capsule_id])).refresh
         end
       end
     end

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

@@ -5,12 +5,15 @@ module Actions
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         input_format do
-          param :pulp_id
+          param :repository_id
+          param :capsule_id
           param :contents_changed
         end
 
         def invoke_external_task
-          pulp_extensions.repository.regenerate_applicability_by_ids([input[:pulp_id]], true)
+          capsule_id = input[:capsule_id] || SmartProxy.default_capsule!.id
+          repo = ::Katello::Repository.find(input[:repository_id])
+          repo.backend_service(smart_proxy(capsule_id)).regenerate_applicability
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Katello
         def kickstart_attributes
           super
 
-          medium_provider = Katello::ManagedContentMediumProvider.new(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) &&

data/app/lib/katello/http_resource.rb

@@ -39,7 +39,7 @@ module Katello
 
       def process_response(resp)
         logger.debug "Processing response: #{resp.code}"
-        logger.debug resp.body
+        logger.debug filter_sensitive_data(resp.body)
         return resp unless resp.code.to_i >= 400
         parsed = {}
         message = "Rest exception while processing the call"
@@ -61,6 +61,10 @@ module Katello
         fail RestClientException, {:message => message, :service_code => service_code, :code => status_code}, caller
       end
 
+      def filter_sensitive_data(payload)
+        payload.gsub(/-----BEGIN RSA PRIVATE KEY-----.*-----END RSA PRIVATE KEY-----/, '[filtered]')
+      end
+
       def print_debug_info(_a_path, headers = {}, payload = {})
         logger.debug "Headers: #{headers.to_json}"
         # calling to_json on file has side-effects breaking manifest import.

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

@@ -35,6 +35,15 @@ module Katello
             consumers
           end
 
+          # workaround for https://bugzilla.redhat.com/1647724
+          def get_all_with_facts(uuids)
+            consumers = []
+            uuids.each do |uuid|
+              consumers << get(uuid)
+            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/"

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

@@ -12,9 +12,8 @@ module Katello
             JSON.parse(content_json).with_indifferent_access
           end
 
-          def all(owner_label, include_only: nil)
-            includes = include_only ? "?#{included_list(include_only)}" : ""
-            content_json = Candlepin::CandlepinResource.get(path(owner_label) + includes, self.default_headers).body
+          def all(owner_label)
+            content_json = Candlepin::CandlepinResource.get(path(owner_label), self.default_headers).body
             JSON.parse(content_json)
           end
 

data/app/lib/katello/util/cdn_var_substitutor.rb

@@ -60,8 +60,7 @@ module Katello
         return resolved if to_resolve.empty?
 
         futures = to_resolve.map do |path_with_substitution|
-          future_namespace = defined?(Concurrent::Promises) ? Concurrent::Promises : Concurrent
-          future_namespace.future do
+          Concurrent::Promises.future do
             path_with_substitution.resolve_substitutions(@resource)
           end
         end

data/app/lib/katello/util/path_with_substitutions.rb

@@ -1,6 +1,8 @@
 module Katello
   module Util
     class PathWithSubstitutions
+      ARCHITECTURES = ["x86_64", "s390x", "ppc64le", "aarch64", "multiarch", "ppc64"].freeze
+
       include Comparable
 
       attr_accessor :substitutions
@@ -12,12 +14,27 @@ module Katello
         @substitutions = substitutions
         @path = path
         @resolved = []
+        check_for_subs_in_path if no_base_arch_passed?
+      end
+
+      def no_base_arch_passed?
+        @substitutions.keys.exclude?("basearch") && substitutions_needed.exclude?("basearch")
+      end
+
+      def split_path
+        @split ||= @path.split('/').map(&:downcase).reject(&:blank?)
+      end
+
+      def check_for_subs_in_path
+        arches = split_path & ARCHITECTURES
+        arch = arches.first
+        @substitutions["basearch"] = arch if arch
       end
 
       def substitutions_needed
         # e.g. if content_url = "/content/dist/rhel/server/7/$releasever/$basearch/kickstart"
         #      return ['releasever', 'basearch']
-        path.split('/').map { |word| word.start_with?('$') ? word[1..-1] : nil }.compact
+        split_path.map { |word| word.start_with?('$') ? word[1..-1] : nil }.compact
       end
 
       def substitutable?

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

@@ -9,14 +9,14 @@ module Katello
           !PuppetModule.exists?(name: record.name, author: record.author)
           record.errors[:base] << _("Puppet Module with name='%{name}' and author='%{author}' does\
                                     not exist") % { name: record.name, author: record.author }
-        elsif record.uuid && !PuppetModule.exists?(uuid: record.uuid)
+        elsif record.uuid && !PuppetModule.exists?(pulp_id: record.uuid)
           record.errors[:base] << _("Puppet Module with uuid='%{uuid}' does not\
                                     exist") % { uuid: record.uuid }
         else
           puppet_modules = if record.uuid.blank?
                              PuppetModule.where(name: record.name, author: record.author)
                            else
-                             PuppetModule.where(uuid: record.uuid)
+                             PuppetModule.where(pulp_id: record.uuid)
                            end
           repositories = puppet_modules.flat_map(&:repositories)
 

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

@@ -20,19 +20,21 @@ module Katello
 
       def self.validate_repositories(registry_name_pattern, repositories)
         error_messages = []
-        names = []
+        name_to_repos = {}
         repositories.each do |repository|
           name = Katello::Repository.safe_render_container_name(repository, registry_name_pattern)
-
           unless ContainerImageNameValidator.validate_name(name)
             error_messages << N_("Registry name pattern results in invalid container image name of member repository '%{name}'") % {name: repository.name}
             return error_messages
           end
-          names << name
+          name_to_repos[name] ||= []
+          name_to_repos[name] << repository
         end
 
-        if names.length != names.uniq.length
-          error_messages << N_("Registry name pattern results in duplicate container image names")
+        duplicate_repos = name_to_repos.select { |_name, repos| repos.count > 1 }.values.flatten
+        if duplicate_repos.any?
+          repo_names = duplicate_repos.map(&:name).sort.join(', ')
+          error_messages << N_("Registry name pattern results in duplicate container image names for these repositories: %s.") % repo_names
           return error_messages
         end
 

data/app/models/katello/concerns/hostgroup_extensions.rb

@@ -88,19 +88,14 @@ module Katello
       end
 
       def equivalent_kickstart_repository
-        return unless operatingsystem &&
-                      kickstart_repository &&
-                      operatingsystem.respond_to?(:kickstart_repos)
+        return unless operatingsystem && kickstart_repository
         ks_repos = operatingsystem.kickstart_repos(self)
         ks_repos.find { |repo| repo[:name] == kickstart_repository.label }
       end
 
       def matching_kickstart_repository?
         return true unless operatingsystem
-
-        if operatingsystem.respond_to? :kickstart_repos
-          return operatingsystem.kickstart_repos(self).any? { |repo| repo[:id] == kickstart_repository_id }
-        end
+        operatingsystem.kickstart_repos(self).any? { |repo| repo[:id] == kickstart_repository_id }
       end
 
       private

data/app/models/katello/concerns/organization_extensions.rb

@@ -68,7 +68,7 @@ module Katello
         end
 
         def active_pools_count
-          self.pools.count { |p| p[:activeSubscription] == true }
+          self.pools.where.not(:unmapped_guest => true).count
         end
 
         def anonymous_provider
@@ -203,6 +203,16 @@ module Katello
           users.pluck(:id)
         end
 
+        def audit_manifest_action(message)
+          self.manifest_refreshed_at = Time.now
+          self.audit_comment = message
+          # we skip validating here because the complex taxonomy relationships can cause a lot of unexpected issues.
+          # This should be a simple transaction that happens on an important action in the user's workflow.
+          # It would be hard to create any new invalid relationships at this step, so the validation
+          # doesn't provide much benefit for the frustration it creates.
+          self.save(validate: false)
+        end
+
         class Jail < ::Safemode::Jail
           allow :name, :label
         end

data/app/models/katello/concerns/pulp_database_unit.rb

@@ -9,7 +9,7 @@ module Katello
     #  Class#update_from_json
 
     def backend_data
-      self.class.pulp_data(uuid) || {}
+      self.class.pulp_data(pulp_id) || {}
     end
 
     module ClassMethods
@@ -33,26 +33,30 @@ module Katello
         ids = [ids] unless ids.is_a?(Array)
         ids.map!(&:to_s)
         id_integers = ids.map { |string| Integer(string) rescue -1 }
-        where("#{self.table_name}.id in (?) or #{self.table_name}.uuid in (?)", id_integers, ids)
+        where("#{self.table_name}.id in (?) or #{self.table_name}.pulp_id in (?)", id_integers, ids)
       end
 
       def in_repositories(repos)
-        where(:id => repository_association_class.where(:repository_id => repos).select(unit_id_field))
+        if manage_repository_association
+          where(:id => repository_association_class.where(:repository_id => repos).select(unit_id_field))
+        else
+          where(:repository_id => repos)
+        end
       end
 
-      def pulp_data(uuid)
-        content_unit_class.new(uuid)
+      def pulp_data(pulp_id)
+        content_unit_class.new(pulp_id)
       end
 
       # Import all units of a single type and refresh their repository associations
-      def import_all(uuids = nil, options = {})
+      def import_all(pulp_ids = nil, options = {})
         index_repository_association = options.fetch(:index_repository_association, true) && self.manage_repository_association
 
         process_block = lambda do |units|
           units.each do |unit|
             unit = unit.with_indifferent_access
             item = Katello::Util::Support.active_record_retry do
-              self.where(:uuid => unit['_id']).first_or_create
+              self.where(:pulp_id => unit['_id']).first_or_create
             end
             item.update_from_json(unit)
           end
@@ -63,8 +67,8 @@ module Katello
           end
         end
 
-        if uuids
-          results = content_unit_class.fetch_by_uuids(uuids, &process_block).flatten
+        if pulp_ids
+          results = content_unit_class.fetch_by_uuids(pulp_ids, &process_block).flatten
           update_repository_associations(results, true) if index_repository_association
         else
           results = content_unit_class.fetch_all(&process_block).flatten
@@ -78,12 +82,12 @@ module Katello
         # in our database. Errata and Package Groups can change in Pulp, so we index
         # all of them in the repository on each sync.
         if immutable_unit_types.include?(self) && !force
-          ids_to_import = ids - repository.rpms.map(&:uuid)
+          ids_to_import = ids - repository.rpms.map(&:pulp_id)
         else
           ids_to_import = ids
         end
         self.import_all(ids_to_import, :index_repository_association => false) if repository.content_view.default? || force
-        self.sync_repository_associations(repository, :uuids => ids) if self.manage_repository_association
+        self.sync_repository_associations(repository, :pulp_ids => ids) if self.manage_repository_association
       end
 
       def unit_id_field
@@ -91,23 +95,35 @@ module Katello
       end
 
       def copy_repository_associations(source_repo, dest_repo)
-        delete_query = "delete from #{repository_association_class.table_name} where repository_id = #{dest_repo.id} and
-                       #{unit_id_field} not in (select #{unit_id_field} from #{repository_association_class.table_name} where repository_id = #{source_repo.id})"
-        ActiveRecord::Base.connection.execute(delete_query)
+        if manage_repository_association
+          delete_query = "delete from #{repository_association_class.table_name} where repository_id = #{dest_repo.id} and
+                         #{unit_id_field} not in (select #{unit_id_field} from #{repository_association_class.table_name} where repository_id = #{source_repo.id})"
+
+          insert_query = "insert into #{repository_association_class.table_name} (repository_id, #{unit_id_field})
+                          select #{dest_repo.id} as repository_id, #{unit_id_field} from #{repository_association_class.table_name}
+                          where repository_id = #{source_repo.id} and #{unit_id_field} not in (select #{unit_id_field}
+                          from #{repository_association_class.table_name} where repository_id = #{dest_repo.id})"
+        else
+          columns = column_names - ["id", "pulp_id", "created_at", "updated_at", "repository_id"]
 
-        insert_query = "insert into #{repository_association_class.table_name} (repository_id, #{unit_id_field})
-                        select #{dest_repo.id} as repository_id, #{unit_id_field} from #{repository_association_class.table_name}
-                        where repository_id = #{source_repo.id} and #{unit_id_field} not in (select #{unit_id_field}
-                        from #{repository_association_class.table_name} where repository_id = #{dest_repo.id})"
+          delete_query = "delete from #{self.table_name} where repository_id = #{dest_repo.id} and
+                          pulp_id not in (select pulp_id from #{self.table_name} where repository_id = #{source_repo.id})"
+          insert_query = "insert into #{self.table_name} (repository_id, pulp_id, #{columns.join(',')})
+                    select #{dest_repo.id} as repository_id, pulp_id, #{columns.join(',')} from #{self.table_name}
+                    where repository_id = #{source_repo.id} and pulp_id not in (select pulp_id
+                    from #{self.table_name} where repository_id = #{dest_repo.id})"
+
+        end
+        ActiveRecord::Base.connection.execute(delete_query)
         ActiveRecord::Base.connection.execute(insert_query)
       end
 
       def sync_repository_associations(repository, options = {})
         additive = options.fetch(:additive, false)
         associated_ids = options.fetch(:ids, nil)
-        uuids = options.fetch(:uuids) if associated_ids.nil?
+        pulp_ids = options.fetch(:pulp_ids) if associated_ids.nil?
 
-        associated_ids = with_uuid(uuids).pluck(:id) if uuids
+        associated_ids = with_pulp_id(pulp_ids).pluck(:id) if pulp_ids
 
         table_name = self.repository_association_class.table_name
         attribute_name = unit_id_field
@@ -136,8 +152,8 @@ module Katello
         end
       end
 
-      def with_uuid(unit_uuids)
-        where(:uuid => unit_uuids)
+      def with_pulp_id(unit_pulp_ids)
+        where(:pulp_id => unit_pulp_ids)
       end
 
       def update_repository_associations(units_json, additive = false)
@@ -153,8 +169,8 @@ module Katello
             end
           end
 
-          repo_unit_id.each do |repo_pulp_id, unit_uuids|
-            sync_repository_associations(Repository.find_by(:pulp_id => repo_pulp_id), :uuids => unit_uuids, :additive => additive)
+          repo_unit_id.each do |repo_pulp_id, unit_pulp_ids|
+            sync_repository_associations(Repository.find_by(:pulp_id => repo_pulp_id), :pulp_ids => unit_pulp_ids, :additive => additive)
           end
         end
       end

data/app/models/katello/concerns/redhat_extensions.rb

@@ -41,7 +41,11 @@ module Katello
       end
 
       def kickstart_repos(host)
-        distros = distribution_repositories(host).where(distribution_bootable: true)
+        distribution_repos = distribution_repositories(host)
+
+        return [] if distribution_repos.empty?
+
+        distros = distribution_repos.where(distribution_bootable: true)
         if distros && host.content_source
           distros.map { |distro| distro.to_hash(host.content_source) }
         else
@@ -51,7 +55,7 @@ module Katello
 
       def variant_repo(host, variant)
         if variant && host.content_source
-          product_id = host.try(:content_facet).try(:kickstart_repository).try(:product_id) || host.try(:kickstart_repository).try(:product_id)
+          product_id = host&.content_facet&.kickstart_repository&.product_id
           distro = distribution_repositories(host)
             .joins(:product)
             .where(
@@ -71,7 +75,7 @@ module Katello
               where(:distribution_version => host.os.release,
                     :distribution_arch => host.architecture.name)
         else
-          Katello::Repository.none
+          []
         end
       end
     end

data/app/models/katello/content_view.rb

@@ -519,25 +519,22 @@ module Katello
       build_puppet_env(options).save!
     end
 
-    def computed_module_ids_by_repoid
-      uuids = []
+    def computed_modules_by_repoid
       names_and_authors = []
       puppet_modules = []
 
       if composite?
-        uuids = component_modules_to_publish.collect { |puppet_module| puppet_module.uuid }
+        puppet_modules = component_modules_to_publish
       else
         puppet_modules_to_publish.each do |cvpm|
           if cvpm.uuid
-            uuids << cvpm.uuid
+            puppet_modules << cvpm.puppet_module
           else
             names_and_authors << { :name => cvpm.name, :author => cvpm.author }
           end
         end
       end
 
-      puppet_modules = PuppetModule.where(:uuid => uuids).to_a if uuids.present?
-
       if names_and_authors.present?
         names_and_authors.each do |name_and_author|
           puppet_module = ::Katello::PuppetModule.latest_module(
@@ -571,7 +568,8 @@ module Katello
 
         error_messages = ::Katello::Validators::EnvironmentDockerRepositoriesValidator.validate_repositories(environment.registry_name_pattern, repositories)
         unless error_messages.empty?
-          fail _("Content View publish to environment %{name} will result in invalid container image name of member repositories") % {name: environment.name}
+          error_messages << _("Consider changing the Lifecycle Environment's Registry Name Pattern to something more specific.")
+          fail error_messages.join("  ")
         end
       end
       true