katello 3.5.2 → 3.6.0.rc1

data/app/models/katello/deb.rb

@@ -0,0 +1,50 @@
+module Katello
+  class Deb < Katello::Model
+    include Concerns::PulpDatabaseUnit
+
+    CONTENT_TYPE = Pulp::Deb::CONTENT_TYPE
+
+    has_many :repositories, :through => :repository_debs, :class_name => "Katello::Repository"
+    has_many :repository_debs, :class_name => "Katello::RepositoryDeb", :dependent => :destroy, :inverse_of => :deb
+
+    scoped_search :on => :name, :complete_value => true
+    scoped_search :on => :version, :complete_value => true
+    scoped_search :on => :architecture, :complete_value => true
+    scoped_search :on => :filename, :complete_value => true
+    scoped_search :on => :checksum
+
+    before_save lambda { |deb| deb.description = deb.description.truncate(255) unless deb.description.blank? }
+
+    def self.default_sort
+      order(:name).order(:version).order(:architecture)
+    end
+
+    def self.repository_association_class
+      RepositoryDeb
+    end
+
+    def self.search_version_range(min = nil, max = nil)
+      query = self.all
+      query = Katello::Util::PackageFilter.new(query, min, Katello::Util::PackageFilter::GREATER_THAN).results if min
+      query = Katello::Util::PackageFilter.new(query, max, Katello::Util::PackageFilter::LESS_THAN).results if max
+      query
+    end
+
+    def self.search_version_equal(version)
+      Katello::Util::PackageFilter.new(self, version, Katello::Util::PackageFilter::EQUAL).results
+    end
+
+    def update_from_json(json)
+      keys = Pulp::Deb::PULP_INDEXED_FIELDS - ['_id']
+      custom_json = json.slice(*keys)
+      if custom_json.any? { |name, value| self.send(name) != value }
+        self.assign_attributes(custom_json)
+        self.save!
+      end
+    end
+
+    def self.total_for_repositories(repos)
+      self.in_repositories(repos).count
+    end
+  end
+end

data/app/models/katello/docker_manifest.rb

@@ -1,31 +1,37 @@
 module Katello
   class DockerManifest < Katello::Model
     include Concerns::PulpDatabaseUnit
-
-    has_many :docker_tags, :dependent => :destroy, :class_name => "Katello::DockerTag", :foreign_key => :docker_manifest_id
-    has_many :repository_docker_manifests, :dependent => :destroy
+    has_many :docker_tags, :as => :docker_taggable, :class_name => "Katello::DockerTag", :dependent => :destroy
+    has_many :repository_docker_manifests, :dependent => :destroy, :inverse_of => :docker_manifest
     has_many :repositories, :through => :repository_docker_manifests, :inverse_of => :docker_manifests
 
+    has_many :docker_manifest_list_manifests, :class_name => "Katello::DockerManifestListManifest",
+             :dependent => :delete_all, :inverse_of => :docker_manifest
+    has_many :docker_manifest_lists, :through => :docker_manifest_list_manifests, :inverse_of => :docker_manifests
+
     CONTENT_TYPE = Pulp::DockerManifest::CONTENT_TYPE
-    scoped_search :on => :name, :complete_value => true
-    scoped_search :relation => :docker_tags, :on => :name, :rename => :tag, :complete_value => true, :only_explicit => true
+    scoped_search :relation => :docker_tags, :on => :name, :rename => :tag, :complete_value => true
     scoped_search :on => :digest, :rename => :digest, :complete_value => true, :only_explicit => true
     scoped_search :on => :schema_version, :rename => :schema_version, :complete_value => true, :only_explicit => true
+    scoped_search :relation => :docker_manifest_lists, :on => :digest, :rename => :manifest_list_digest, :complete_value => true, :only_explicit => true
 
     def self.repository_association_class
       RepositoryDockerManifest
     end
 
     def update_from_json(json)
-      update_attributes(:name => json[:name],
-                        :schema_version => json[:schema_version],
+      update_attributes(:schema_version => json[:schema_version],
                         :digest => json[:digest],
                         :downloaded => json[:downloaded]
                        )
     end
 
     def self.default_sort
-      order(:name).order(:schema_version)
+      order(:schema_version)
+    end
+
+    def manifest_type
+      "image"
     end
   end
 end

data/app/models/katello/docker_manifest_list.rb

@@ -0,0 +1,39 @@
+module Katello
+  class DockerManifestList < Katello::Model
+    include Concerns::PulpDatabaseUnit
+
+    has_many :docker_tags, :as => :docker_taggable, :class_name => "Katello::DockerTag", :dependent => :destroy
+    has_many :repository_docker_manifest_lists, :dependent => :destroy, :inverse_of => :docker_manifest_list
+    has_many :repositories, :through => :repository_docker_manifest_lists, :inverse_of => :docker_manifest_lists
+
+    has_many :docker_manifest_list_manifests, :class_name => "Katello::DockerManifestListManifest",
+             :dependent => :delete_all, :inverse_of => :docker_manifest_list
+    has_many :docker_manifests, :through => :docker_manifest_list_manifests, :inverse_of => :docker_manifest_lists
+
+    CONTENT_TYPE = Pulp::DockerManifestList::CONTENT_TYPE
+
+    scoped_search :relation => :docker_tags, :on => :name, :rename => :tag, :complete_value => true
+    scoped_search :on => :digest, :rename => :digest, :complete_value => true, :only_explicit => true
+    scoped_search :on => :schema_version, :rename => :schema_version, :complete_value => true, :only_explicit => true
+
+    def self.repository_association_class
+      RepositoryDockerManifestList
+    end
+
+    def update_from_json(json)
+      update_attributes(:schema_version => json[:schema_version],
+                        :digest => json[:digest],
+                        :downloaded => json[:downloaded],
+                        :docker_manifests => ::Katello::DockerManifest.where(:digest => json[:manifests])
+                       )
+    end
+
+    def self.default_sort
+      order(:schema_version)
+    end
+
+    def manifest_type
+      "list"
+    end
+  end
+end

data/app/models/katello/docker_manifest_list_manifest.rb

@@ -0,0 +1,6 @@
+module Katello
+  class DockerManifestListManifest < Katello::Model
+    belongs_to :docker_manifest, :inverse_of => :docker_manifest_list_manifests, :class_name => 'Katello::DockerManifest'
+    belongs_to :docker_manifest_list, :inverse_of => :docker_manifest_list_manifests, :class_name => 'Katello::DockerManifestList'
+  end
+end

data/app/models/katello/docker_meta_tag.rb

@@ -46,7 +46,7 @@ module Katello
       end
     end
 
-    delegate_to_tags :full_name, :docker_manifest
+    delegate_to_tags :docker_manifest
     delegate_to_tags :product, :environment, :content_view_version
 
     def repositories
@@ -71,11 +71,11 @@ module Katello
     end
 
     def schema1_manifest
-      schema1.try(:docker_manifest)
+      schema1.try(:docker_taggable)
     end
 
     def schema2_manifest
-      schema2.try(:docker_manifest)
+      schema2.try(:docker_taggable)
     end
 
     def self.with_uuid(ids)

data/app/models/katello/docker_tag.rb

@@ -2,7 +2,7 @@ module Katello
   class DockerTag < Katello::Model
     include Concerns::PulpDatabaseUnit
     include ScopedSearchExtensions
-    belongs_to :docker_manifest, :inverse_of => :docker_tags, :class_name => "Katello::DockerManifest"
+    belongs_to :docker_taggable, :polymorphic => true, :inverse_of => :docker_tags
     belongs_to :repository, :inverse_of => :docker_tags, :class_name => "Katello::Repository"
 
     has_one :schema1_meta_tag, :class_name => "Katello::DockerMetaTag", :foreign_key => "schema1_id",
@@ -22,32 +22,56 @@ module Katello
     end
 
     def associated_meta_tag_identifier
-      associated_meta_tag.id
+      associated_meta_tag.try(:id)
+    end
+
+    def docker_manifest
+      docker_taggable
+    end
+
+    def docker_manifest_id
+      docker_taggable_id
+    end
+
+    def docker_manifest_list
+      docker_taggable
+    end
+
+    def docker_manifest_list_id
+      docker_taggable_id
     end
 
     def self.grouped
       grouped_fields = "#{table_name}.name, #{Repository.table_name}.name, #{Product.table_name}.name"
-      ids = uniq.select("ON (#{grouped_fields}) #{table_name}.id").joins(:repository => :product)
+      ids = distinct.select("ON (#{grouped_fields}) #{table_name}.id").joins(:repository => :product)
       where(:id => ids)
     end
 
     def update_from_json(json)
-      self.docker_manifest_id ||= ::Katello::DockerManifest.find_by(:digest => json['manifest_digest']).try(:id)
-      self.repository_id ||= ::Katello::Repository.find_by(:pulp_id => json['repo_id']).try(:id)
+      taggable_class = json['manifest_type'] == "list" ? ::Katello::DockerManifestList : ::Katello::DockerManifest
+      self.docker_taggable = taggable_class.find_by(:digest => json['manifest_digest'])
+      self.repository_id = ::Katello::Repository.find_by(:pulp_id => json['repo_id']).try(:id)
       self.name = json['name']
       self.save!
     end
 
     def self.import_all(uuids = nil, options = {})
+      ::Katello::DockerTag.destroy_all if uuids.blank?
       super
+      ::Katello::DockerTag.where(:repository_id => nil).destroy_all
       if uuids
-        repos = ::Katello::Repository.joins(:docker_tags).where("katello_docker_tags.uuid" => uuids).uniq
+        repos = ::Katello::Repository.joins(:docker_tags).where("katello_docker_tags.uuid" => uuids).distinct
         ::Katello::DockerMetaTag.import_meta_tags(repos)
       else
         ::Katello::DockerMetaTag.import_meta_tags(::Katello::Repository.docker_type)
       end
     end
 
+    def self.import_for_repository(repository)
+      ::Katello::DockerTag.where(:repository_id => repository).destroy_all
+      super(repository, true)
+    end
+
     def self.manage_repository_association
       false
     end
@@ -57,10 +81,6 @@ module Katello
       [repository]
     end
 
-    def full_name
-      "#{docker_manifest.name}:#{name}"
-    end
-
     def related_tags
       # tags in the same repo group with the same name
       self.class.where(:repository_id => repository.group, :name => name)

data/app/models/katello/errata_status.rb

@@ -19,7 +19,7 @@ module Katello
       when UP_TO_DATE
         N_("All errata applied")
       when UNKNOWN
-        N_("Could not calculate errata status, ensure host is registered and katello-agent is installed")
+        N_("Could not calculate errata status, ensure host is registered and the katello-host-tools package is installed")
       else
         N_("Unknown errata status")
       end

data/app/models/katello/erratum.rb

@@ -9,12 +9,12 @@ module Katello
     TYPES = [SECURITY, BUGZILLA, ENHANCEMENT].freeze
     CONTENT_TYPE = Pulp::Erratum::CONTENT_TYPE
 
-    has_many :content_facets, :through => :content_facet_errata, :class_name => "Katello::Host::ContentFacet", :source => :content_facet
     has_many :content_facet_errata, :class_name => "Katello::ContentFacetErratum", :dependent => :destroy, :inverse_of => :content_facet
+    has_many :content_facets, :through => :content_facet_errata, :class_name => "Katello::Host::ContentFacet", :source => :content_facet
     has_many :content_facets_applicable, :through => :content_facet_errata, :class_name => "Katello::Host::ContentFacet", :source => :content_facet
 
-    has_many :repositories, :through => :repository_errata, :class_name => "Katello::Repository"
     has_many :repository_errata, :class_name => "Katello::RepositoryErratum", :dependent => :destroy, :inverse_of => :erratum
+    has_many :repositories, :through => :repository_errata, :class_name => "Katello::Repository"
 
     has_many :bugzillas, :class_name => "Katello::ErratumBugzilla", :dependent => :destroy, :inverse_of => :erratum
     has_many :cves, :class_name => "Katello::ErratumCve", :dependent => :destroy, :inverse_of => :erratum
@@ -56,8 +56,7 @@ module Katello
     end
 
     def self.applicable_to_hosts_dashboard(hosts)
-      applicable_to_hosts(hosts).
-        select("DISTINCT ON (#{self.table_name}.updated, #{self.table_name}.id) #{self.table_name}.*").
+      Erratum.where(:id => applicable_to_hosts(hosts)).
         order("#{self.table_name}.updated desc").limit(6)
     end
 

data/app/models/katello/file_unit.rb

@@ -6,8 +6,8 @@ module Katello
 
     CONTENT_TYPE = Pulp::FileUnit::CONTENT_TYPE
 
-    has_many :repositories, :through => :repository_files, :class_name => "Katello::Repository"
     has_many :repository_files, :class_name => "Katello::RepositoryFile", :dependent => :destroy, :inverse_of => :file, :foreign_key => :file_id
+    has_many :repositories, :through => :repository_files, :class_name => "Katello::Repository"
 
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :path, :complete_value => true
@@ -35,7 +35,7 @@ module Katello
     end
 
     def self.total_for_repositories(repos)
-      self.in_repositories(repos).uniq.count
+      self.in_repositories(repos).count
     end
   end
 end

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

@@ -1,4 +1,4 @@
-# rubocop:disable Style/AccessorMethodName
+# rubocop:disable Naming/AccessorMethodName
 module Katello
   module Glue::Candlepin::ActivationKey
     def self.included(base)

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

@@ -1,40 +1,15 @@
 module Katello
-  module Glue::Candlepin::Content
-    CANDLEPIN_DOCKER_TYPE = "containerimage".freeze
-    CANDLEPIN_OSTREE_TYPE = "ostree".freeze
+  module Glue
+    module Candlepin
+      module Content
+        extend ActiveSupport::Concern
 
-    def self.included(base)
-      base.send :include, InstanceMethods
-      # required for GPG key url generation
-      base.send :include, Rails.application.routes.url_helpers
-    end
-
-    module InstanceMethods
-      def content
-        return @content unless @content.nil?
-        unless self.content_id.nil?
-          @content = Katello::Candlepin::Content.find(self.organization.label, self.content_id)
+        def modified_product_ids(org)
+          @modified_product_cache ||= {}
+          return @modified_product_cache[org.label] if @modified_product_cache[org.label]
+          result = Resources::Candlepin::Content.get(org.label, self.cp_content_id)
+          @modified_product_cache[org.label] = result['modifiedProductIds']
         end
-        @content
-      rescue RestClient::ResourceNotFound, RestClient::BadRequest
-        nil
-      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?)
-          host = Facter.value(:fqdn) || SETTINGS[:fqdn]
-          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

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

@@ -38,38 +38,6 @@ module Katello
         self.owner_details['contentAccessMode']
       end
 
-      def enabled_product_content_for(repositories)
-        return [] if repositories.blank?
-        content_ids = repositories.pluck(:content_id)
-
-        filtered_product_content do |pc|
-          content_ids.include?(pc.content.id) && pc.product.enabled?
-        end
-      end
-
-      def enabled_product_content
-        filtered_product_content do |pc|
-          pc.product.enabled? && pc.product.redhat?
-        end
-      end
-
-      def filtered_product_content
-        cp_products = Katello::Resources::Candlepin::Product.all(self.label, ['id', 'productContent.enabled', 'productContent.content.name', 'productContent.content.id',
-                                                                              'productContent.content.type', 'productContent.content.contentUrl', 'productContent.content.label'])
-        to_return = []
-
-        cp_products.each do |product_hash|
-          product = ::Katello::Product.find_by(:organization_id => self.id, :cp_id => product_hash['id'])
-          if product
-            product_hash['productContent'].each do |pc_hash|
-              pc = Katello::Candlepin::ProductContent.new(pc_hash, product.id)
-              to_return << pc if !block_given? || yield(pc)
-            end
-          end
-        end
-        to_return.sort_by { |pc| pc.content.name.downcase }
-      end
-
       def pools(consumer_uuid = nil)
         if consumer_uuid
           Resources::Candlepin::Owner.pools self.label, :consumer => consumer_uuid

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

@@ -113,11 +113,11 @@ module Katello
         pool_attributes[:pool_type] = pool_json["type"] if pool_json.key?("type")
 
         if pool_attributes.key?(:multi_entitlement)
-          pool_attributes[:multi_entitlement] = pool_attributes[:multi_entitlement] == "yes" ? true : false
+          pool_attributes[:multi_entitlement] = pool_attributes[:multi_entitlement] == "yes"
         end
 
         if pool_attributes.key?(:virtual)
-          pool_attributes[:virt_only] = pool_attributes["virtual"] == 'true' ? true : false
+          pool_attributes[:virt_only] = pool_attributes["virtual"] == 'true'
         end
 
         if pool_attributes.key?("requires_host")
@@ -141,7 +141,6 @@ module Katello
         self.create_activation_key_associations
         self.import_hosts if index_hosts
       end
-      # rubocop:enable MethodLength
 
       def import_hosts
         entitlements = Resources::Candlepin::Pool.entitlements(self.cp_id, ["consumer.uuid"])

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

@@ -1,19 +1,13 @@
 module Katello
   module Glue::Candlepin::Product
-    PRODUCT_ATTRS = %w(name attributes.name attributes.value
-                       productContent.content.contentUrl
-                       productContent.content.label
-                       productContent.content.modifiedProductIds
-                       productContent.content.type
-                       productContent.content.id
-                       productContent.content.name).freeze
+    PRODUCT_ATTRS = %w(name attributes.name attributes.value).freeze
 
     def self.included(base)
       base.send :include, LazyAccessor
       base.send :include, InstanceMethods
 
       base.class_eval do
-        lazy_accessor :productContent, :multiplier, :href, :attrs,
+        lazy_accessor :multiplier, :href, :attrs,
           :initializer => (lambda do |_s|
             convert_from_cp_fields(
               Resources::Candlepin::Product.get(self.organization.label, cp_id, PRODUCT_ATTRS)[0]
@@ -46,9 +40,7 @@ module Katello
 
       product = Product.new(attrs, &block)
       product.save!
-      product.productContent_will_change!
-      product.productContent = product.build_product_content(product_content_attrs)
-      product.save!
+      import_product_content(product, product_content_attrs)
     rescue => e
       [Rails.logger, import_logger].each do |logger|
         logger.error "Failed to create product #{attrs['name']}: #{e}" if logger
@@ -56,6 +48,37 @@ module Katello
       raise e
     end
 
+    def self.import_product_content(product, content_attrs)
+      content_attrs.each do |attrs|
+        params = attrs.with_indifferent_access
+        pc = params[:content]
+
+        content_attrs = {
+          cp_content_id: pc[:id],
+          name: pc[:name],
+          label: pc[:label],
+          content_type: pc[:type],
+          vendor: pc[:vendor],
+          gpg_url: pc[:gpgUrl],
+          content_url: pc[:contentUrl]
+        }
+
+        # current product has this content - update it
+        # otherwise create a reference to existing content OR new content altogether
+        if (existing = product.product_content_by_id(pc[:id]))
+          existing.content.update_attributes!(content_attrs)
+          existing.update_attributes(enabled: params['enabled'])
+        else
+          content = ::Katello::Content.find_by_cp_content_id(pc[:id])
+          content ||= ::Katello::Content.create!(content_attrs)
+
+          ::Katello::ProductContent.create!(enabled: params[:enabled],
+                                            product_id: product.id,
+                                            content: content)
+        end
+      end
+    end
+
     module InstanceMethods
       def initialize(attribs = nil)
         unless attribs.nil?
@@ -65,8 +88,6 @@ module Katello
             attribs.delete(attributes_key)
           end
 
-          @productContent = [] unless attribs.key?(:productContent)
-
           # ugh. hack-ish. otherwise we have to modify code every time things change on cp side
           attribs = attribs.reject do |k, _v|
             !self.class.column_defaults.keys.member?(k.to_s) && (!respond_to?(:"#{k.to_s}=") rescue true)
@@ -76,18 +97,10 @@ module Katello
         super
       end
 
-      def displayable_product_contents
-        self.productContent.select(&:displayable?)
-      end
-
       def orphaned?
         self.provider.redhat_provider? && self.certificate.nil?
       end
 
-      def build_product_content(attrs)
-        @productContent = attrs.collect { |pc| Katello::Candlepin::ProductContent.new pc }
-      end
-
       def support_level
         return _attr(:support_level)
       end
@@ -119,7 +132,6 @@ module Katello
 
       def convert_from_cp_fields(cp_json)
         ar_safe_json = cp_json.key?(:attributes) ? cp_json.merge(:attrs => cp_json.delete(:attributes)) : cp_json
-        ar_safe_json[:productContent] = ar_safe_json[:productContent].collect { |pc| ::Katello::Candlepin::ProductContent.new(pc, self.id) }
         ar_safe_json[:attrs] = remove_hibernate_fields(cp_json[:attrs]) if ar_safe_json.key?(:attrs)
         ar_safe_json[:attrs] ||= []
         ar_safe_json.except('id')
@@ -137,14 +149,6 @@ module Katello
         self.productContent << content
       end
 
-      def product_content_by_id(content_id)
-        self.productContent.find { |pc| pc.content.id == content_id }
-      end
-
-      def product_content_by_name(content_name)
-        self.productContent.find { |pc| pc.content.name == content_name }
-      end
-
       def import_subscription(subscription_id)
         sub = nil
         ::Katello::Util::Support.active_record_retry do
@@ -154,28 +158,6 @@ module Katello
         pools = ::Katello::Resources::Candlepin::Product.pools(self.organization.label, self.cp_id)
         pools.each { |pool_json| ::Katello::Pool.import_pool(pool_json['id']) }
       end
-
-      protected
-
-      def added_content
-        old_content_ids = productContent_change[0].nil? ? [] : productContent_change[0].map { |pc| pc.content.label }
-        new_content_ids = productContent_change[1].map { |pc| pc.content.label }
-
-        added_content_ids = new_content_ids - old_content_ids
-
-        added_content = productContent_change[1].select { |pc| added_content_ids.include?(pc.content.label) }
-        added_content
-      end
-
-      def deleted_content
-        old_content_ids = productContent_change[0].nil? ? [] : productContent_change[0].map { |pc| pc.content.label }
-        new_content_ids = productContent_change[1].map { |pc| pc.content.label }
-
-        deleted_content_ids = old_content_ids - new_content_ids
-
-        deleted_content = productContent_change[0].select { |pc| deleted_content_ids.include?(pc.content.label) }
-        deleted_content
-      end
     end
   end
 end