katello 3.10.2 → 3.11.0.rc1

data/app/models/katello/content_view_docker_filter.rb

@@ -23,7 +23,7 @@ module Katello
 
     protected
 
-    def fetch_tag_uuids(repo, rule, manifest_klass = DockerManifest)
+    def fetch_tag_pulp_ids(repo, rule, manifest_klass = DockerManifest)
       query_name = rule.name.tr("*", "%")
       tags_query = ::Katello::DockerTag.where(:repository => repo).
                                         where(:docker_taggable_type => manifest_klass.name).
@@ -33,14 +33,14 @@ module Katello
       query = manifest_klass.in_repositories(repo).where("id in (#{tags_query.to_sql})")
       names = query.all.collect do |manifest|
         manifest.docker_tags.where(:repository => repo).where("name ilike ?", query_name).all.collect do |tag|
-          tag.uuid
+          tag.pulp_id
         end
       end
       names.flatten.uniq
     end
 
     def query_manifests(repo, rule)
-      (fetch_tag_uuids(repo, rule, DockerManifest) + fetch_tag_uuids(repo, rule, DockerManifestList)).flatten.uniq
+      (fetch_tag_pulp_ids(repo, rule, DockerManifest) + fetch_tag_pulp_ids(repo, rule, DockerManifestList)).flatten.uniq
     end
   end
 end

data/app/models/katello/content_view_puppet_environment.rb

@@ -102,7 +102,7 @@ module Katello
     end
 
     def index_content(puppet_module_uuids)
-      associated_ids = PuppetModule.with_uuid(puppet_module_uuids).pluck(:id)
+      associated_ids = PuppetModule.with_pulp_id(puppet_module_uuids).pluck(:id)
       self.puppet_modules = PuppetModule.where(:id => associated_ids)
       self.save!
     end

data/app/models/katello/content_view_puppet_module.rb

@@ -18,12 +18,12 @@ module Katello
     before_validation :set_attributes
 
     def puppet_module
-      PuppetModule.find_by_uuid(self.uuid)
+      PuppetModule.find_by(:pulp_id => self.uuid)
     end
 
     def computed_version
       if self.uuid
-        puppet_module = PuppetModule.where(:uuid => self.uuid).first
+        puppet_module = PuppetModule.where(:pulp_id => self.uuid).first
       else
         puppet_module = PuppetModule.latest_module(
           self.name,
@@ -43,7 +43,6 @@ module Katello
     private
 
     def set_attributes
-      return unless SETTINGS[:katello][:use_pulp]
       if self.uuid.present?
         puppet_module = PuppetModule.with_identifiers(self.uuid).first
         fail Errors::NotFound, _("Couldn't find Puppet Module with id '%s'") % self.uuid unless puppet_module

data/app/models/katello/docker_meta_tag.rb

@@ -108,7 +108,7 @@ module Katello
       schema2.try(:docker_taggable)
     end
 
-    def self.with_uuid(ids)
+    def self.with_pulp_id(ids)
       self.with_identifiers(ids)
     end
 

data/app/models/katello/docker_tag.rb

@@ -13,8 +13,6 @@ module Katello
 
     before_destroy :cleanup_meta_tags
 
-    scope :in_repositories, ->(repos) { where(:repository_id => repos) }
-
     delegate :relative_path, :environment, :content_view_version, :product, :to => :repository
 
     def associated_meta_tag
@@ -55,12 +53,12 @@ module Katello
       self.save!
     end
 
-    def self.import_all(uuids = nil, options = {})
-      ::Katello::DockerTag.destroy_all if uuids.blank?
+    def self.import_all(pulp_ids = nil, options = {})
+      ::Katello::DockerTag.destroy_all if pulp_ids.blank?
       super
       ::Katello::DockerTag.where(:repository_id => nil).destroy_all
-      if uuids
-        repos = ::Katello::Repository.joins(:docker_tags).where("katello_docker_tags.uuid" => uuids).distinct
+      if pulp_ids
+        repos = ::Katello::Repository.joins(:docker_tags).where("katello_docker_tags.pulp_id" => pulp_ids).distinct
         ::Katello::DockerMetaTag.import_meta_tags(repos)
       else
         ::Katello::DockerMetaTag.import_meta_tags(::Katello::Repository.docker_type)

data/app/models/katello/erratum.rb

@@ -74,7 +74,7 @@ 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 (?) or #{self.table_name}.errata_id in (?)", id_integers, ids, ids)
+      where("#{self.table_name}.id in (?) or #{self.table_name}.pulp_id in (?) or #{self.table_name}.errata_id in (?)", id_integers, ids, ids)
     end
 
     def hosts_applicable(org_id = nil)

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

@@ -415,6 +415,7 @@ module Katello
         Katello::ModuleStream.import_for_repository(self)
         Katello::Erratum.import_for_repository(self)
         Katello::PackageGroup.import_for_repository(self)
+        Katello::YumMetadataFile.import_for_repository(self)
         self.import_distribution_data
       else
         index_linked_repo
@@ -427,6 +428,8 @@ module Katello
         Erratum.copy_repository_associations(base_repo, self)
         PackageGroup.copy_repository_associations(base_repo, self)
         ModuleStream.copy_repository_associations(base_repo, self)
+        YumMetadataFile.copy_repository_associations(base_repo, self)
+
         self.update_attributes!(
           :distribution_version => base_repo.distribution_version,
           :distribution_arch => base_repo.distribution_arch,

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

@@ -34,6 +34,10 @@ module Katello
     end
 
     module InstanceMethods
+      def empty?
+        return self.repos(library).empty?
+      end
+
       def distributions(env)
         to_ret = []
         self.repos(env).each do |repo|

data/app/models/katello/host/info_provider.rb

@@ -28,7 +28,7 @@ module Katello
           'label' => host.content_view.try(:label),
           'latest-version' => host.content_view.try(:latest_version),
           'version' => content_version.try(:version),
-          'published' => content_version.try(:created_at).try(:time).to_s,
+          'published' => content_version.try(:created_at).try(:time),
           'components' => content_view_components
         }
 
@@ -43,7 +43,7 @@ module Katello
           cv_label = cv.component_version.content_view.label
           components[cv_label] = {}
           components[cv_label]['version'] = cv.component_version.try(:version)
-          components[cv_label]['published'] = cv.component_version.try(:created_at).try(:time).to_s
+          components[cv_label]['published'] = cv.component_version.try(:created_at).try(:time)
         end
         components
       end

data/app/models/katello/host/subscription_facet.rb

@@ -31,7 +31,6 @@ module Katello
 
       def update_from_consumer_attributes(consumer_params)
         import_database_attributes(consumer_params)
-        self.hypervisor_guest_uuids = consumer_params['guestIds'] unless consumer_params['hypervisor_guest_uuids'].blank?
         self.facts = consumer_params['facts'] unless consumer_params['facts'].blank?
       end
 

data/app/models/katello/module_stream.rb

@@ -15,7 +15,7 @@ module Katello
     has_many :content_facets, :through => :content_facet_applicable_module_streams, :class_name => "Katello::Host::ContentFacet"
 
     scoped_search on: :name, complete_value: true
-    scoped_search on: :uuid, complete_value: true
+    scoped_search on: :pulp_id, complete_value: true, rename: :uuid
     scoped_search on: :stream, complete_value: true
     scoped_search on: :version, complete_value: true
     scoped_search on: :context, complete_value: true
@@ -61,15 +61,21 @@ module Katello
 
     def create_stream_artifacts(artifacts)
       artifacts.each do |name|
-        self.artifacts.where(name: name).first_or_create!
+        Katello::Util::Support.active_record_retry do
+          self.artifacts.where(name: name).first_or_create!
+        end
       end
     end
 
     def create_profiles(profiles)
       profiles.select do |profile, rpms|
-        profile = self.profiles.where(name: profile).first_or_create!
+        Katello::Util::Support.active_record_retry do
+          profile = self.profiles.where(name: profile).first_or_create!
+        end
         rpms.each do |rpm|
-          profile.rpms.where(name: rpm).first_or_create!
+          Katello::Util::Support.active_record_retry do
+            profile.rpms.where(name: rpm).first_or_create!
+          end
         end
       end
     end

data/app/models/katello/ostree_branch.rb

@@ -8,7 +8,8 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version, :complete_value => true
     scoped_search :on => :commit, :complete_value => true
-    scoped_search :on => :uuid, :complete_value => true
+    scoped_search :on => :pulp_id, :complete_value => true, :rename => :uuid
+    scoped_search :on => :version_date, :complete_value => true, :rename => :created
 
     CONTENT_TYPE = Pulp::OstreeBranch::CONTENT_TYPE
 
@@ -19,7 +20,8 @@ module Katello
     def update_from_json(json)
       update_attributes(:name => json[:branch],
                         :version => json[:metadata][:version],
-                        :commit => json[:commit]
+                        :commit => json[:commit],
+                        :version_date => json[:_created].to_datetime
                        )
     end
   end

data/app/models/katello/package_group.rb

@@ -9,7 +9,7 @@ module Katello
     has_many :roots, :through => :repositories, :class_name => "Katello::RootRepository"
 
     scoped_search :on => :name, :complete_value => true
-    scoped_search :on => :uuid, :rename => :id, :complete_value => true
+    scoped_search :on => :pulp_id, :rename => :id, :complete_value => true
 
     def self.repository_association_class
       RepositoryPackageGroup
@@ -36,7 +36,7 @@ module Katello
     end
 
     def package_names
-      group = Pulp::PackageGroup.new(self.uuid)
+      group = Pulp::PackageGroup.new(self.pulp_id)
       group.default_package_names + group.conditional_package_names + group.optional_package_names + group.mandatory_package_names
     end
   end

data/app/models/katello/ping.rb

@@ -71,7 +71,7 @@ module Katello
 
           checks = executors.map { |executor| world.ping(executor.id, timeout) }
           checks.each(&:wait)
-          if checks.any?(&:failed?)
+          if checks.any?(&:rejected?)
             fail _("some executors are not responding, check %{status_url}") % { :status_url => '/foreman_tasks/dynflow/status' }
           end
         end

data/app/models/katello/puppet_module.rb

@@ -24,7 +24,7 @@ module Katello
     scoped_search :on => :version, :complete_value => true
     scoped_search :on => :summary
 
-    validates :uuid, :presence => true
+    validates :pulp_id, :presence => true
     validates :name, :presence => true
     validates :author, :presence => true
 
@@ -65,8 +65,8 @@ module Katello
         repo = puppet_module.repositories.first
 
         if repo
-          result[repo.pulp_id] ||= []
-          result[repo.pulp_id] << puppet_module.uuid
+          result[repo.id] ||= []
+          result[repo.id] << puppet_module
         else
           fail _("Could not find Repository for module %s.") % puppet_module.name
         end

data/app/models/katello/repository.rb

@@ -62,6 +62,8 @@ module Katello
     has_many :repository_docker_manifest_lists, :class_name => "Katello::RepositoryDockerManifestList", :dependent => :delete_all
     has_many :docker_manifest_lists, :through => :repository_docker_manifest_lists
 
+    has_many :yum_metadata_files, :dependent => :destroy, :class_name => "Katello::YumMetadataFile"
+
     has_many :docker_tags, :dependent => :destroy, :class_name => "Katello::DockerTag"
 
     has_many :docker_meta_tags, :dependent => :destroy, :class_name => "Katello::DockerMetaTag"
@@ -159,6 +161,10 @@ module Katello
       @service ||= Katello::Pulp::Repository.instance_for_type(self, smart_proxy)
     end
 
+    def backend_content_service(smart_proxy)
+      backend_service(smart_proxy).content_service
+    end
+
     def organization
       if self.environment
         self.environment.organization
@@ -275,6 +281,13 @@ module Katello
       end
     end
 
+    def empty_errata!
+      found = empty_errata.to_a
+      yield(found) if block_given?
+      self.repository_errata.where(:erratum_id => found.map(&:id)).delete_all
+      found
+    end
+
     def clones
       self.root.repositories.where.not(:id => library_instance_id || id)
     end
@@ -501,7 +514,7 @@ module Katello
       if is_integer
         self.removable_unit_association.where("#{table_name}.id in (?)", ids)
       else
-        self.removable_unit_association.where("#{table_name}.uuid in (?)", ids)
+        self.removable_unit_association.where("#{table_name}.pulp_id in (?)", ids)
       end
     end
 
@@ -752,7 +765,7 @@ module Katello
     end
 
     class Jail < ::Safemode::Jail
-      allow :name, :label, :docker_upstream_name, :url
+      allow :name, :label, :docker_upstream_name
     end
   end
 end

data/app/models/katello/root_repository.rb

@@ -47,6 +47,7 @@ module Katello
     validate :ensure_ostree_repo_protected, :if => :ostree?
     validate :ensure_compatible_download_policy, :if => :yum?
     validate :ensure_valid_ignorable_content
+    validate :ensure_valid_docker_tags_whitelist
     validate :ensure_content_attribute_restrictions
     validate :ensure_valid_upstream_authorization
     validates :url, presence: true, if: :ostree?
@@ -173,6 +174,15 @@ module Katello
       end
     end
 
+    def ensure_valid_docker_tags_whitelist
+      return if docker_tags_whitelist.blank?
+      if !docker?
+        errors.add(:docker_tags_whitelist, N_("White list can be only set for Container Image repositories."))
+      elsif !docker_tags_whitelist.is_a?(Array)
+        errors.add(:docker_tags_whitelist, N_("Invalid value specified for Container Image repositories."))
+      end
+    end
+
     def ensure_valid_upstream_authorization
       return if (self.upstream_username.blank? && self.upstream_password.blank?)
       if redhat?

data/app/models/katello/yum_metadata_file.rb

@@ -0,0 +1,46 @@
+module Katello
+  class YumMetadataFile < Katello::Model
+    include Concerns::PulpDatabaseUnit
+    include ScopedSearchExtensions
+    belongs_to :repository, :inverse_of => :yum_metadata_files, :class_name => "Katello::Repository"
+    CONTENT_TYPE = Pulp::YumMetadataFile::CONTENT_TYPE
+
+    def update_from_json(json)
+      shared_attributes = json.keys & self.class.column_names
+      shared_json = json.select { |key, _v| shared_attributes.include?(key) }
+      repo = ::Katello::Repository.find_by(:pulp_id => json['repo_id']).try(:id)
+      self.update_attributes!(shared_json.merge(repository_id: repo,
+                                                name: find_name_from_json(json)))
+    end
+
+    def find_name_from_json(json)
+      # get the name of the metadata file.
+      # Notice that pulp does not have a way to get name of the metadata file
+      # so we infer it from the _storage_path
+      # for example from the following storage path
+      #  "/var/lib/pulp/content/units/yum_repo_metadata_file/..../050-productid.gz"
+      # we find the right most '/' and return everything after that
+      # i.e ->  "050-productid.gz"
+      path = json["_storage_path"]
+      path[path.rindex('/') + 1..-1]
+    end
+
+    def self.import_for_repository(repository)
+      ::Katello::YumMetadataFile.where(:repository_id => repository).destroy_all
+      super(repository, true)
+    end
+
+    def self.manage_repository_association
+      false
+    end
+
+    # yum metadata file only has one repo
+    def repositories
+      [repository]
+    end
+
+    def self.completer_scope_options
+      {"#{Katello::Repository.table_name}" => lambda { |repo_class| repo_class.yum_type } }
+    end
+  end
+end

data/app/services/katello/abstract/pulp/content.rb

@@ -0,0 +1,19 @@
+module Katello
+  module Abstract
+    module Pulp
+      module Content
+        def create_upload
+          fail NotImplementedError
+        end
+
+        def upload_chunk
+          fail NotImplementedError
+        end
+
+        def delete_upload
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/app/services/katello/applicable_content_helper.rb

@@ -84,7 +84,7 @@ module Katello
     def applicable_differences(partial)
       content_uuids = ::Katello::Pulp::Consumer.new(content_facet.uuid).applicable_ids(content_type)
       if partial
-        consumer_uuids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.uuid")
+        consumer_uuids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.pulp_id")
         to_remove = consumer_uuids - content_uuids
         to_add = content_uuids - consumer_uuids
       else
@@ -94,8 +94,8 @@ module Katello
       [to_add, to_remove]
     end
 
-    def insert(uuids)
-      applicable_ids = content_unit_class.where(:uuid => uuids).pluck(:id)
+    def insert(pulp_ids)
+      applicable_ids = content_unit_class.where(:pulp_id => pulp_ids).pluck(:id)
       unless applicable_ids.empty?
         inserts = applicable_ids.map { |applicable_id| "(#{applicable_id.to_i}, #{content_facet.id.to_i})" }
         sql = "INSERT INTO #{content_facet_association_class.table_name} (#{content_unit_association_id}, content_facet_id) VALUES #{inserts.join(', ')}"
@@ -103,8 +103,8 @@ module Katello
       end
     end
 
-    def remove(uuids)
-      applicable_ids = content_unit_class.where(:uuid => uuids).pluck(:id)
+    def remove(pulp_ids)
+      applicable_ids = content_unit_class.where(:pulp_id => pulp_ids).pluck(:id)
       content_facet_association_class.where(:content_facet_id => content_facet.id, content_unit_association_id => applicable_ids).delete_all
     end
   end

data/app/services/katello/pulp/content.rb

@@ -0,0 +1,17 @@
+module Katello
+  module Pulp
+    class Content
+      extend Katello::Abstract::Pulp::Content
+      class << self
+        extend Forwardable
+        def_delegator :pulp_content, :create_upload_request, :create_upload
+        def_delegator :pulp_content, :delete_upload_request, :delete_upload
+        def_delegator :pulp_content, :upload_bits, :upload_chunk
+
+        private def pulp_content
+          SmartProxy.pulp_master.pulp_api.resources.content
+        end
+      end
+    end
+  end
+end