katello 3.8.1 → 3.9.0.rc1

data/app/models/katello/docker_manifest_list.rb

@@ -25,7 +25,7 @@ module Katello
       update_attributes(:schema_version => json[:schema_version],
                         :digest => json[:digest],
                         :downloaded => json[:downloaded],
-                        :docker_manifests => ::Katello::DockerManifest.where(:digest => json[:manifests])
+                        :docker_manifests => ::Katello::DockerManifest.where(:digest => json[:manifests].pluck(:digest))
                        )
     end
 

data/app/models/katello/docker_meta_tag.rb

@@ -1,6 +1,7 @@
 module Katello
   class DockerMetaTag < Katello::Model
     include ScopedSearchExtensions
+
     belongs_to :repository, :inverse_of => :docker_meta_tags, :class_name => "Katello::Repository"
 
     belongs_to :schema1, :class_name => "Katello::DockerTag",
@@ -10,14 +11,22 @@ module Katello
                           :inverse_of => :schema2_meta_tag
 
     scoped_search :on => :name, :complete_value => true, :rename => :tag
+    scoped_search :on => :id, :only_explicit => true
+    scoped_search :on => :name, :complete_value => true
     scoped_search :on => :schema_version, :rename => :schema_version, :complete_value => { "1" => "1", "2" => "2"},
                   :only_explicit => true, :ext_method => :find_by_schema_version, :operators => ["="]
-    scoped_search :relation => :repository, :on => :name, :rename => :repository,
-                  :complete_value => true, :only_explicit => true
     scoped_search :relation => :repository, :on => :container_repository_name, :rename => :image,
                   :complete_value => true, :only_explicit => true
     scoped_search :on => :digest, :rename => :digest, :complete_value => false,
                   :only_explicit => true, :ext_method => :find_by_digest, :operators => ["="]
+    scoped_search :relation => :repositories, :on => :name, :rename => :repository, :complete_value => true,
+                  :ext_method => :search_by_repo_name, :only_explicit => true
+
+    def self.search_by_repo_name(_key, operator, value)
+      conditions = sanitize_sql_for_conditions(["#{Katello::RootRepository.table_name}.name #{operator} ?", value_to_sql(operator, value)])
+      query = self.joins(:repository => :root).where(conditions).select('id')
+      {:conditions => "#{self.table_name}.id IN (#{query.to_sql})"}
+    end
 
     def self.meta_tags_by_digest_query(operator, digest, manifest_klass)
       search = "digest #{operator} ?"

data/app/models/katello/docker_tag.rb

@@ -42,7 +42,7 @@ module Katello
     end
 
     def self.grouped
-      grouped_fields = "#{table_name}.name, #{Repository.table_name}.name, #{Product.table_name}.name"
+      grouped_fields = "#{table_name}.name, #{Repository.table_name}.root_id, #{Product.table_name}.name"
       ids = distinct.select("ON (#{grouped_fields}) #{table_name}.id").joins(:repository => :product)
       where(:id => ids)
     end

data/app/models/katello/erratum.rb

@@ -20,9 +20,11 @@ module Katello
     has_many :cves, :class_name => "Katello::ErratumCve", :dependent => :destroy, :inverse_of => :erratum
     has_many :packages, :class_name => "Katello::ErratumPackage", :dependent => :destroy, :inverse_of => :erratum
 
+    scoped_search :on => :errata_id, :only_explicit => true
     scoped_search :on => :errata_id, :rename => :id, :complete_value => true, :only_explicit => true
     scoped_search :on => :title, :only_explicit => true
     scoped_search :on => :severity, :complete_value => true
+    scoped_search :on => :errata_type, :only_explicit => true
     scoped_search :on => :errata_type, :rename => :type, :complete_value => true
     scoped_search :on => :issued, :complete_value => true
     scoped_search :on => :updated, :complete_value => true
@@ -210,5 +212,9 @@ module Katello
       end
       run_until(needed_function, action_function)
     end
+
+    class Jail < ::Safemode::Jail
+      allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested
+    end
   end
 end

data/app/models/katello/file_unit.rb

@@ -12,7 +12,6 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :path, :complete_value => true
     scoped_search :on => :checksum
-    scoped_search :relation => :repositories, :on => :name, :rename => :repository, :complete_value => true
 
     def self.default_sort
       order(:name)

data/app/models/katello/glue/candlepin/owner.rb

@@ -11,6 +11,7 @@ module Katello
 
         lazy_accessor :events, :initializer => lambda { |_s| Resources::Candlepin::Owner.events(label) }
         lazy_accessor :service_levels, :initializer => lambda { |_s| Resources::Candlepin::Owner.service_levels(label) }
+        lazy_accessor :system_purposes, :initializer => lambda { |_s| Resources::Candlepin::Owner.system_purpose(label) }
         lazy_accessor :debug_cert, :initializer => lambda { |_s| load_debug_cert }
       end
     end

data/app/models/katello/glue/candlepin/pool.rb

@@ -163,8 +163,7 @@ module Katello
       end
 
       def import_hosts
-        entitlements = Resources::Candlepin::Pool.entitlements(self.cp_id, ["consumer.uuid"])
-        uuids = entitlements.map { |ent| ent["consumer"]["uuid"] }
+        uuids = Resources::Candlepin::Pool.consumer_uuids(self.cp_id)
 
         sub_facet_ids_from_cp = Katello::Host::SubscriptionFacet.where(:uuid => uuids).select(:id).pluck(:id)
         sub_facet_ids_from_pool_table = Katello::SubscriptionFacetPool.where(:pool_id => self.id).select(:subscription_facet_id).pluck(:subscription_facet_id)

data/app/models/katello/glue/candlepin/product.rb

@@ -107,10 +107,6 @@ module Katello
         super
       end
 
-      def orphaned?
-        self.provider.redhat_provider? && self.certificate.nil?
-      end
-
       def support_level
         return _attr(:support_level)
       end

data/app/models/katello/glue/candlepin/repository.rb

@@ -10,27 +10,10 @@ module Katello
     end
 
     module InstanceMethods
-      def substitutions
-        {
-          :releasever => self.minor,
-          :basearch => self.arch
-        }
-      end
-
       def content
         Katello::Content.find_by(:cp_content_id => self.content_id, :organization_id => self.product.organization_id)
       end
 
-      def calculate_updated_name
-        fail _("Cannot calculate name for custom repos") if custom?
-        Katello::Candlepin::RepositoryMapper.new(self.product, self.content, self.substitutions).name
-      end
-
-      def should_update_content?
-        (self.gpg_key_id_was.nil? && !self.gpg_key_id.nil? && self.content.gpgUrl == '') ||
-            (!self.gpg_key_id_was.nil? && self.gpg_key_id.nil? && self.content.gpgUrl != '')
-      end
-
       def yum_gpg_key_url
         # if the repo has a gpg key return a url to access it
         if (gpg_key && gpg_key.content.present?)
@@ -38,10 +21,6 @@ module Katello
           gpg_key_content_api_repository_url(self, :host => host + "/katello", :protocol => 'https')
         end
       end
-
-      def custom_content_label
-        "#{organization.label} #{product.label} #{label}".gsub(/\s/, "_")
-      end
     end
   end
 end

data/app/models/katello/glue/provider.rb

@@ -5,6 +5,8 @@ module Katello
     end
 
     module InstanceMethods
+      API_URL = 'https://subscription.rhsm.redhat.com/subscription/consumers/'.freeze
+
       def sync
         Rails.logger.debug "Syncing provider #{name}"
         syncs = self.products.collect do |p|
@@ -60,7 +62,7 @@ module Katello
         end
 
         # Default to Red Hat
-        url = upstream['apiUrl'] || 'https://subscription.rhn.redhat.com/subscription/consumers/'
+        url = upstream['apiUrl'] || API_URL
 
         # TODO: wait until ca_path is supported
         #       https://github.com/L2G/rest-client-fork/pull/8
@@ -83,7 +85,7 @@ module Katello
         end
 
         # Default to Red Hat
-        url = upstream['apiUrl'] || 'https://subscription.rhn.redhat.com/subscription/consumers/'
+        url = upstream['apiUrl'] || API_URL
 
         # TODO: wait until ca_path is supported
         #       https://github.com/L2G/rest-client-fork/pull/8

data/app/models/katello/glue/pulp/repo.rb

@@ -3,7 +3,6 @@ module Katello
     # TODO: move into submodules
     # rubocop:disable MethodLength
     # rubocop:disable ModuleLength
-    # rubocop:disable Metrics/AbcSize
     def self.included(base)
       base.send :include, LazyAccessor
       base.send :include, InstanceMethods
@@ -26,34 +25,6 @@ module Katello
         lazy_accessor :distributors,
                       :initializer => lambda { |_s| pulp_repo_facts["distributors"] if pulp_id }
 
-        def self.ensure_sync_notification
-          results = {:existing => [], :deleted => []}
-          resource = Katello.pulp_server.resources.event_notifier
-          url = SETTINGS[:katello][:post_sync_url]
-          type = Runcible::Resources::EventNotifier::EventTypes::REPO_SYNC_COMPLETE
-          notifs = resource.list
-
-          # delete any similar tasks with the wrong url (in case it changed)
-          notifs.select { |n| n['event_types'] == [type] }.each do |e|
-            if e['notifier_config']['url'] != url
-              resource.delete(e['id'])
-              results[:deleted] << e
-            else
-              results[:existing] << e
-            end
-          end
-
-          #only create a notifier if one doesn't exist with the correct url
-          exists = notifs.select { |n| n['event_types'] == [type] && n['notifier_config']['url'] == url }
-
-          if exists.empty?
-            resource.create(Runcible::Resources::EventNotifier::NotifierTypes::REST_API, {:url => url}, [type])
-            results[:created] = url
-          end
-
-          results
-        end
-
         def self.delete_orphaned_content
           Katello.pulp_server.resources.content.remove_orphans
         end
@@ -185,10 +156,11 @@ module Katello
           options[:upstream_name] = capsule.default_capsule? ? self.docker_upstream_name : self.container_repository_name
           options[:feed] = docker_feed_url(capsule)
           options[:enable_v1] = false
+          options[:tags] = capsule.default_capsule? ? self.docker_tags_whitelist : nil
           Runcible::Models::DockerImporter.new(importer_connection_options(capsule).merge(options))
         when Repository::OSTREE_TYPE
           options = importer_connection_options(capsule)
-          options[:depth] = capsule.default_capsule? ? compute_ostree_upstream_sync_depth : ostree_capsule_sync_depth
+          options[:depth] = capsule.default_capsule? ? root.compute_ostree_upstream_sync_depth : ostree_capsule_sync_depth
           options[:feed] = self.importer_feed_url(capsule)
           Runcible::Models::OstreeImporter.new(options)
         when Repository::DEB_TYPE
@@ -299,7 +271,7 @@ module Katello
           yum_dist_options = {:protected => true, :id => yum_dist_id, :auto_publish => true}
           yum_dist_options[:skip] = ignorable_content if ignorable_content
           #check the instance variable, as we do not want to go to pulp
-          yum_dist_options['checksum_type'] = self.checksum_type
+          yum_dist_options['checksum_type'] = self.saved_checksum_type || self.checksum_type
           yum_dist = Runcible::Models::YumDistributor.new(self.relative_path, self.unprotected, true,
                                                           yum_dist_options)
           clone_dist = Runcible::Models::YumCloneDistributor.new(:id => "#{self.pulp_id}_clone",
@@ -334,7 +306,7 @@ module Katello
           options = { :id => self.pulp_id,
                       :auto_publish => true,
                       :relative_path => relative_path,
-                      :depth => self.compute_ostree_upstream_sync_depth }
+                      :depth => self.root.compute_ostree_upstream_sync_depth }
 
           dist = Runcible::Models::OstreeDistributor.new(options)
           distributors = [dist]
@@ -379,14 +351,6 @@ module Katello
         !found.nil?
       end
 
-      def other_repos_with_same_product_and_content
-        Repository.where(:content_id => self.content_id).in_product(self.product).pluck(:pulp_id) - [self.pulp_id]
-      end
-
-      def other_repos_with_same_content
-        Repository.where(:content_id => self.content_id).pluck(:pulp_id) - [self.pulp_id]
-      end
-
       def package_group_count
         content_unit_counts = 0
         if self.pulp_repo_facts
@@ -395,61 +359,6 @@ module Katello
         content_unit_counts
       end
 
-      # remove errata and groups from this repo
-      # that have no packages
-      def purge_empty_groups_errata
-        package_lists = package_lists_for_publish
-        rpm_names = package_lists[:names]
-        filenames = package_lists[:filenames]
-
-        # Remove all errata with no packages
-        errata_to_delete = errata.collect do |erratum|
-          erratum.errata_id if filenames.intersection(erratum.package_filenames).empty?
-        end
-        errata_to_delete.compact!
-
-        #do the errata remove call
-        unless errata_to_delete.empty?
-          unassociate_by_filter(ContentViewErratumFilter::CONTENT_TYPE,
-                                 "id" => { "$in" => errata_to_delete })
-        end
-
-        # Remove all  package groups with no packages
-        package_groups_to_delete = package_groups.collect do |group|
-          group.package_group_id if rpm_names.intersection(group.package_names).empty?
-        end
-        package_groups_to_delete.compact!
-
-        unless package_groups_to_delete.empty?
-          unassociate_by_filter(ContentViewPackageGroupFilter::CONTENT_TYPE,
-                                 "id" => { "$in" => package_groups_to_delete })
-        end
-      end
-
-      def sync_schedule(date_and_time)
-        if date_and_time
-          Katello.pulp_server.extensions.repository.create_or_update_schedule(self.pulp_id, importer_type, date_and_time)
-        else
-          Katello.pulp_server.extensions.repository.remove_schedules(self.pulp_id, importer_type)
-        end
-      end
-
-      def find_packages_by_name(name)
-        Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name
-      end
-
-      def find_packages_by_nvre(name, version, release, epoch)
-        Katello.pulp_server.extensions.repository.rpms_by_nvre self.pulp_id, name, version, release, epoch
-      end
-
-      def pulp_update_needed?
-        changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync
-                                   upstream_username upstream_password ostree_upstream_sync_policy ostree_upstream_sync_depth ignore_global_proxy ignorable_content)
-        changeable_attributes += %w(name container_repository_name) if docker?
-        changeable_attributes += %w(deb_releases deb_components deb_architectures) if deb?
-        changeable_attributes.any? { |key| previous_changes.key?(key) }
-      end
-
       def sync(options = {})
         sync_options = {}
         sync_options[:max_speed] ||= SETTINGS[:katello][:pulp][:sync_KBlimit] if SETTINGS[:katello][:pulp][:sync_KBlimit] # set bandwidth limit
@@ -465,59 +374,6 @@ module Katello
         return [task]
       end
 
-      def clone_contents_by_filter(to_repo, content_type, filter_clauses, override_config = {})
-        content_classes = {
-          Katello::Rpm::CONTENT_TYPE => :rpm,
-          Katello::PackageGroup::CONTENT_TYPE => :package_group,
-          Katello::Erratum::CONTENT_TYPE => :errata,
-          Katello::PuppetModule::CONTENT_TYPE => :puppet_module
-        }
-        fail "Invalid content type #{content_type} sent. It needs to be one of #{content_classes.keys}"\
-                                                                       unless content_classes[content_type]
-        criteria = {}
-        case content_type
-        when Runcible::Extensions::Rpm.content_type
-          criteria[:fields] = Pulp::Rpm::PULP_SELECT_FIELDS
-        when Runcible::Extensions::Errata.content_type
-          criteria[:fields] = Pulp::Erratum::PULP_SELECT_FIELDS
-        end
-
-        if filter_clauses && !filter_clauses.empty?
-          if content_type == Runcible::Extensions::PuppetModule.content_type
-            criteria[:filters] = {:association => filter_clauses}
-          else
-            criteria[:filters] = {:unit => filter_clauses}
-          end
-        end
-        criteria[:override_config] = override_config unless override_config.empty?
-        Katello.pulp_server.extensions.send(content_classes[content_type]).copy(self.pulp_id, to_repo.pulp_id, criteria)
-      end
-
-      def clone_contents(to_repo)
-        events = []
-
-        if self.content_type == Repository::PUPPET_TYPE
-          events << Katello.pulp_server.extensions.puppet_module.copy(self.pulp_id, to_repo.pulp_id)
-        else
-          # In order to reduce the memory usage of pulp during the copy process,
-          # include the fields that will uniquely identify the rpm. If no fields
-          # are listed, pulp will retrieve every field it knows about for the rpm
-          # (e.g. changelog, filelist...etc).
-          events << Katello.pulp_server.extensions.rpm.copy(self.pulp_id, to_repo.pulp_id,
-                                                    :fields => Pulp::Rpm::PULP_SELECT_FIELDS)
-
-          # Since the rpms will be copied above, during the copy of errata and package groups,
-          # include the copy_children flag to request that pulp skip copying them again.
-          events << Katello.pulp_server.extensions.errata.copy(self.pulp_id, to_repo.pulp_id,
-                                                    :fields => Pulp::Erratum::PULP_SELECT_FIELDS,
-                                                    :copy_children => false)
-          events << Katello.pulp_server.extensions.package_group.copy(self.pulp_id, to_repo.pulp_id, :copy_children => false)
-          events << clone_file_metadata(to_repo)
-        end
-
-        events
-      end
-
       def clone_file_metadata(to_repo)
         Katello.pulp_server.extensions.yum_repo_metadata_file.copy(self.pulp_id, to_repo.pulp_id)
       end
@@ -544,7 +400,8 @@ module Katello
       def content_types
         [Katello.pulp_server.extensions.errata,
          Katello.pulp_server.extensions.package_group,
-         Katello.pulp_server.extensions.puppet_module
+         Katello.pulp_server.extensions.puppet_module,
+         Katello.pulp_server.extensions.module_stream
         ]
       end
 
@@ -637,28 +494,6 @@ module Katello
         Katello.pulp_server.extensions.repository.unit_search(self.pulp_id, options)
       end
 
-      # A helper method used by purge_empty_groups_errata
-      # to obtain a list of package filenames and names
-      # so that it could mix/match empty package groups
-      # and errata and purge them.
-      def package_lists_for_publish
-        names = []
-        filenames = []
-        rpm_list = []
-        rpm_ids = Katello::Pulp::Rpm.ids_for_repository(self)
-        rpm_ids.each_slice(SETTINGS[:katello][:pulp][:bulk_load_size]) do |sub_list|
-          rpm_list.concat(Katello.pulp_server.extensions.rpm.find_all_by_unit_ids(
-                                  sub_list, %w(filename name), :include_repos => false))
-        end
-
-        rpm_list.each do |rpm|
-          filenames << rpm["filename"]
-          names << rpm["name"]
-        end
-        {:names => names.to_set,
-         :filenames => filenames.to_set}
-      end
-
       def docker?
         self.content_type == Repository::DOCKER_TYPE
       end
@@ -691,7 +526,7 @@ module Katello
         policy = capsule.download_policy || Setting[:default_proxy_download_policy]
         if self.yum?
           if policy == ::SmartProxy::DOWNLOAD_INHERIT
-            (self.library_instance || self).download_policy
+            self.root.download_policy
           else
             policy
           end
@@ -790,7 +625,7 @@ module Katello
       elsif ostree?
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/ostree/web/#{relative_path}"
       elsif deb?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/deb/#{relative_path}"
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/deb/#{relative_path}/"
       else
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/repos/#{relative_path}/"
       end
@@ -802,6 +637,7 @@ module Katello
         Katello::Srpm.import_for_repository(self, full_index)
         Katello::Erratum.import_for_repository(self)
         Katello::PackageGroup.import_for_repository(self)
+        Katello::ModuleStream.import_for_repository(self)
         self.import_distribution_data
       else
         index_linked_repo
@@ -813,6 +649,7 @@ module Katello
         Rpm.copy_repository_associations(base_repo, self)
         Erratum.copy_repository_associations(base_repo, self)
         PackageGroup.copy_repository_associations(base_repo, self)
+        ModuleStream.copy_repository_associations(base_repo, self)
         self.update_attributes!(
           :distribution_version => base_repo.distribution_version,
           :distribution_arch => base_repo.distribution_arch,