katello 3.4.2 → 3.4.4

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

@@ -76,7 +76,7 @@ module Katello
       #  RecordNotUnique exceptions
       def self.active_record_retry(retries = 3)
         yield
-      rescue ActiveRecord::RecordNotUnique => e
+      rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
         retries -= 1
         if retries == 0
           raise e

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

@@ -22,9 +22,9 @@ module Katello
 
     module ClassMethods
       def readable
-        in_products = Repository.where(:product_id => Katello::Product.authorized(:view_products)).pluck(:id)
-        in_content_views = Repository.joins(:content_view_repositories).where("#{ContentViewRepository.table_name}.content_view_id" => Katello::ContentView.readable).pluck(:id)
-        in_versions = Repository.joins(:content_view_version).where("#{Katello::ContentViewVersion.table_name}.content_view_id" => Katello::ContentView.readable).pluck(:id)
+        in_products = Repository.where(:product_id => Katello::Product.authorized(:view_products)).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 (?)", in_products, in_content_views, in_versions)
       end
 

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

@@ -21,7 +21,7 @@ module Katello
               provisioning_template_name = Setting["katello_default_#{kind.name}"]
             end
 
-            if (template = ProvisioningTemplate.find_by_name(provisioning_template_name))
+            if (template = ProvisioningTemplate.unscoped.find_by_name(provisioning_template_name))
               provisioning_templates << template unless provisioning_templates.include?(template)
               if OsDefaultTemplate.where(:template_kind_id => kind.id, :operatingsystem_id => id).empty?
                 OsDefaultTemplate.create(:template_kind_id => kind.id, :provisioning_template_id => template.id, :operatingsystem_id => id)
@@ -29,7 +29,7 @@ module Katello
             end
           end
 
-          if (ptable = Ptable.find_by_name(Setting["katello_default_ptable"]))
+          if (ptable = Ptable.unscoped.find_by_name(Setting["katello_default_ptable"]))
             ptables << ptable unless ptables.include?(ptable)
           end
         end

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

@@ -32,7 +32,7 @@ module Katello
       end
 
       def in_repositories(repos)
-        self.joins(repository_association.to_sym).where("#{repository_association_class.table_name}.repository_id" => repos)
+        where(:id => repository_association_class.where(:repository_id => repos).select(unit_id_field))
       end
 
       def pulp_data(uuid)

data/app/models/katello/docker_manifest.rb

@@ -2,7 +2,7 @@ module Katello
   class DockerManifest < Katello::Model
     include Concerns::PulpDatabaseUnit
 
-    has_many :docker_tags, :dependent => :destroy, :class_name => "Katello::DockerTag"
+    has_many :docker_tags, :dependent => :destroy, :class_name => "Katello::DockerTag", :foreign_key => :docker_manifest_id
     has_many :repository_docker_manifests, :dependent => :destroy
     has_many :repositories, :through => :repository_docker_manifests, :inverse_of => :docker_manifests
 
@@ -21,5 +21,9 @@ module Katello
                         :downloaded => json[:downloaded]
                        )
     end
+
+    def self.default_sort
+      order(:name).order(:schema_version)
+    end
   end
 end

data/app/models/katello/docker_meta_tag.rb

@@ -0,0 +1,108 @@
+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",
+                          :inverse_of => :schema1_meta_tag
+
+    belongs_to :schema2, :class_name => "Katello::DockerTag",
+                          :inverse_of => :schema2_meta_tag
+
+    def self.delegate_to_tags(*names)
+      names.each do |name|
+        define_method(name) do
+          if schema2
+            schema2.send(name)
+          else
+            schema1.send(name)
+          end
+        end
+      end
+    end
+
+    delegate_to_tags :full_name, :docker_manifest
+    delegate_to_tags :product, :environment, :content_view_version
+
+    def repositories
+      [self.repository]
+    end
+
+    def self.in_repositories(repos, grouped = false)
+      if grouped
+        search_in_tags(DockerTag.in_repositories(repos).grouped)
+      else
+        search_in_tags(DockerTag.in_repositories(repos))
+      end
+    end
+
+    def self.search_in_tags(tags)
+      sql = tags.select("#{::Katello::DockerTag.table_name}.id").to_sql
+      self.where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
+    end
+
+    def schema1_manifest
+      schema1.try(:docker_manifest)
+    end
+
+    def schema2_manifest
+      schema2.try(:docker_manifest)
+    end
+
+    def self.with_identifiers(ids)
+      self.where(:id => ids)
+    end
+
+    def self.cleanup_tags
+      self.where(:schema2_id => nil, :schema1_id => nil).delete_all
+    end
+
+    def self.import_meta_tags(repositories)
+      repositories.each do |repo|
+        tag_table_values = get_tag_table_values(repo)
+        meta_tag_table_values = DockerMetaTag.where(:repository => repo).
+                                  select(:schema1_id, :schema2_id, :name).map do |meta_tag|
+          [meta_tag.schema1_id, meta_tag.schema2_id, meta_tag.name]
+        end
+
+        # Delete [meta_tag_table_values - tag_table_values], insert [tag_table_values - meta_tag_table_values]
+
+        docker_meta_tag_arel_table = ::Katello::DockerMetaTag.arel_table
+        params_to_query_for_delete = (meta_tag_table_values - tag_table_values).map do |schema1, schema2, name|
+          conditional = docker_meta_tag_arel_table[:schema1_id].eq(schema1).and(
+                        docker_meta_tag_arel_table[:schema2_id].eq(schema2)).and(
+                        docker_meta_tag_arel_table[:name].eq(name)).to_sql
+
+          "(#{conditional})"
+        end
+
+        unless params_to_query_for_delete.empty?
+          ::Katello::DockerMetaTag.where(:repository => repo).
+                                   where(params_to_query_for_delete.join(" OR ")).delete_all
+        end
+
+        (tag_table_values - meta_tag_table_values).each do |schema1, schema2, name|
+          DockerMetaTag.where(:schema1_id => schema1,
+                              :schema2_id => schema2,
+                              :name => name,
+                              :repository => repo).create!
+        end
+      end
+    end
+
+    def self.get_tag_table_values(repo)
+      # queries DockerTags for a repo and retuns a [schema1, schema2 , name] tuple combination
+      tags = ::Katello::DockerTag.where(:repository_id => repo.id)
+      dups = tags.group_by(&:name)
+
+      dups.map do |name, values|
+        if values.first.docker_manifest.schema_version == 1
+          schema1, schema2 = values
+        else
+          schema2, schema1 = values
+        end
+        [schema1.try(:id), schema2.try(:id), name]
+      end
+    end
+  end
+end

data/app/models/katello/docker_tag.rb

@@ -2,14 +2,22 @@ module Katello
   class DockerTag < Katello::Model
     include Concerns::PulpDatabaseUnit
     include ScopedSearchExtensions
-    belongs_to :docker_manifest, :inverse_of => :docker_tags
+    belongs_to :docker_manifest, :inverse_of => :docker_tags, :class_name => "Katello::DockerManifest"
     belongs_to :repository, :inverse_of => :docker_tags, :class_name => "Katello::Repository"
 
+    has_one :schema1_meta_tag, :class_name => "Katello::DockerMetaTag", :foreign_key => "schema1_id",
+                               :inverse_of => :schema1, :dependent => :nullify
+
+    has_one :schema2_meta_tag, :class_name => "Katello::DockerMetaTag", :foreign_key => "schema2_id",
+                               :inverse_of => :schema2, :dependent => :nullify
+
     scoped_search :on => :name, :complete_value => true, :rename => :tag
     scoped_search :relation => :docker_manifest, :on => :name, :rename => :manifest,
       :complete_value => true, :only_explicit => false
     scoped_search :relation => :docker_manifest, :on => :digest, :rename => :digest,
       :complete_value => false, :only_explicit => true
+    scoped_search :relation => :docker_manifest, :on => :schema_version, :rename => :schema_version,
+      :complete_value => false, :only_explicit => true
     scoped_search :relation => :repository, :on => :name, :rename => :repository,
       :complete_value => true, :only_explicit => true
 
@@ -30,6 +38,16 @@ module Katello
       self.save!
     end
 
+    def self.import_all(uuids = nil, options = {})
+      super
+      if uuids
+        repos = ::Katello::Repository.joins(:docker_tags).where("katello_docker_tags.uuid" => uuids).uniq
+        ::Katello::DockerMetaTag.import_meta_tags(repos)
+      else
+        ::Katello::DockerMetaTag.import_meta_tags(::Katello::Repository.docker_type)
+      end
+    end
+
     def self.manage_repository_association
       false
     end

data/app/models/katello/erratum.rb

@@ -52,7 +52,7 @@ module Katello
       # which is calculated elsewhere.
 
       self.joins(:content_facets).
-        where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts).uniq
+        where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts)
     end
 
     def self.applicable_to_hosts_dashboard(hosts)
@@ -89,21 +89,31 @@ module Katello
     end
 
     def self.installable_for_hosts(hosts = nil)
+      self.where(:id => ids_installable_for_hosts(hosts))
+    end
+
+    def self.ids_installable_for_hosts(hosts = nil)
+      hosts = ::Host.where(:id => hosts) if hosts && hosts.is_a?(Array)
+
       # Main goal of this query
       # 1) Get me the applicable errata for these set of hosts
       # 2) Now further prune this list. Only include errata from repos that have been "enabled" on those hosts.
       #    In other words, prune the list to only include the errate in the "bound" repositories signified by
       #    the inner join between ContentFacetRepository and RepositoryErratum
-      query = self.
+      query = self.joins(:content_facet_errata).
         joins("INNER JOIN #{Katello::ContentFacetRepository.table_name} on \
         #{Katello::ContentFacetRepository.table_name}.content_facet_id = #{Katello::ContentFacetErratum.table_name}.content_facet_id").
         joins("INNER JOIN #{Katello::RepositoryErratum.table_name} AS host_repo_errata ON \
           host_repo_errata.erratum_id = #{Katello::Erratum.table_name}.id AND \
           #{Katello::ContentFacetRepository.table_name}.repository_id = host_repo_errata.repository_id")
-      query = query.joins(:content_facet_errata) unless hosts
 
-      query = query.joins(:content_facets).where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts.map(&:id)) if hosts
-      query.uniq
+      if hosts
+        query = query.where("#{Katello::ContentFacetRepository.table_name}.content_facet_id" => hosts.joins(:content_facet))
+      else
+        query = query.joins(:content_facet_errata)
+      end
+
+      query
     end
 
     def update_from_json(json)
@@ -113,7 +123,7 @@ module Katello
       if self.updated.blank? || (custom_json['updated'].to_datetime != self.updated.to_datetime)
         custom_json['errata_id'] = custom_json.delete('id')
         custom_json['errata_type'] = custom_json.delete('type')
-
+        custom_json['updated'] = custom_json['updated'].blank? ? custom_json['issued'] : custom_json['updated']
         self.update_attributes!(custom_json)
 
         unless json['references'].blank?

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

@@ -31,19 +31,20 @@ module Katello
         where("#{self.table_name}.id = (?) or #{self.table_name}.cp_id = (?)", id_integers, ids)
       end
 
-      def import_all
-        candlepin_ids = []
+      def import_all(organization = nil)
+        organizations = organization ? [organization] : Organization.all
 
-        Organization.all.each do |org|
+        organizations.each do |org|
           import_candlepin_ids(org.label)
-          candlepin_ids.concat(get_candlepin_ids(org.label))
-        end
-
-        self.all.each do |item|
-          if candlepin_ids.include?(item.cp_id)
-            item.import_data
-          else
-            item.destroy
+          candlepin_ids = get_candlepin_ids(org.label)
+
+          objects = self.in_organization(org) + self.where(:cp_id => candlepin_ids)
+          objects.uniq.each do |item|
+            if candlepin_ids.include?(item.cp_id)
+              item.import_data
+            else
+              item.destroy
+            end
           end
         end
       end

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

@@ -49,7 +49,9 @@ module Katello
         cp_product_ids.each do |cp_id|
           product = ::Katello::Product.where(:cp_id => cp_id, :organization_id => self.organization_id)
           if product.any?
-            ::Katello::SubscriptionProduct.where(:subscription_id => self.id, :product_id => product.first.id).first_or_create
+            ::Katello::Util::Support.active_record_retry do
+              ::Katello::SubscriptionProduct.where(:subscription_id => self.id, :product_id => product.first.id).first_or_create
+            end
           end
         end
       end

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

@@ -191,13 +191,13 @@ module Katello
           Rails.logger.warn "Orphaned Product id #{product.id} found while refreshing/importing manifest."
         end
 
-        self.index_subscriptions
+        self.index_subscriptions(self.organization)
         true
       end
 
-      def index_subscriptions
-        Katello::Subscription.import_all
-        Katello::Pool.import_all
+      def index_subscriptions(organization = nil)
+        Katello::Subscription.import_all(organization)
+        Katello::Pool.import_all(organization)
       end
 
       def rules_source

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

@@ -654,6 +654,31 @@ module Katello
         end
       end
 
+      def needs_metadata_publish?
+        last_publish = last_publish_task.try(:[], 'finish_time')
+        last_sync = last_sync_task.try(:[], 'finish_time')
+        return false if last_sync.nil?
+        return true if last_publish.nil?
+
+        DateTime.parse(last_sync) >= DateTime.parse(last_publish)
+      end
+
+      def last_sync_task
+        tasks = Katello.pulp_server.extensions.repository.sync_status(self.pulp_id)
+        most_recent_task(tasks)
+      end
+
+      def last_publish_task
+        tasks = Katello.pulp_server.extensions.repository.publish_status(self.pulp_id)
+        most_recent_task(tasks, true)
+      end
+
+      def most_recent_task(tasks, only_successful = false)
+        tasks = tasks.select { |t| t['finish_time'] }.sort_by { |t| t['finish_time'] }
+        tasks = tasks.select { |task| task['error'].nil? } if only_successful
+        tasks.last
+      end
+
       def filtered_distribution_config_equal?(generated_config, actual_config)
         generated = generated_config.clone
         actual = actual_config.clone

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

@@ -125,7 +125,7 @@ module Katello
       end
 
       def self.with_non_installable_errata(errata)
-        subquery = Katello::Erratum.select("#{Katello::Erratum.table_name}.id").installable_for_hosts
+        subquery = Katello::Erratum.select("#{Katello::Erratum.table_name}.id").ids_installable_for_hosts
         .where("#{Katello::ContentFacetRepository.table_name}.content_facet_id = #{Katello::Host::ContentFacet.table_name}.id").to_sql
         self.joins(:applicable_errata).where("#{Katello::Erratum.table_name}.id" => errata).where("#{Katello::Erratum.table_name}.id NOT IN (#{subquery})").uniq
       end

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

@@ -28,7 +28,7 @@ module Katello
         update_guests(consumer_params)
 
         self.autoheal = consumer_params['autoheal'] unless consumer_params['autoheal'].blank?
-        self.service_level = consumer_params['serviceLevel'] unless consumer_params['serviceLevel'].blank?
+        self.service_level = consumer_params['serviceLevel'] unless consumer_params['serviceLevel'].nil?
         self.registered_at = consumer_params['created'] unless consumer_params['created'].blank?
         self.last_checkin = consumer_params['lastCheckin'] unless consumer_params['lastCheckin'].blank?
 

data/app/models/katello/pool.rb

@@ -7,7 +7,7 @@ module Katello
     has_many :activation_keys, :through => :pool_activation_keys, :class_name => "Katello::ActivationKey"
     has_many :pool_activation_keys, :class_name => "Katello::PoolActivationKey", :dependent => :destroy, :inverse_of => :pool
 
-    scope :in_org, ->(org_id) { joins(:subscription).where("#{Katello::Subscription.table_name}.organization_id = ?", org_id) }
+    scope :in_organization, ->(org_id) { joins(:subscription).where("#{Katello::Subscription.table_name}.organization_id = ?", org_id) }
     scope :for_activation_key, ->(ak) { joins(:activation_keys).where("#{Katello::ActivationKey.table_name}.id" => ak.id) }
 
     self.include_root_in_json = false

data/app/models/katello/repository.rb

@@ -64,6 +64,8 @@ module Katello
 
     has_many :docker_tags, :dependent => :destroy, :class_name => "Katello::DockerTag"
 
+    has_many :docker_meta_tags, :dependent => :destroy, :class_name => "Katello::DockerMetaTag"
+
     has_many :repository_ostree_branches, :class_name => "Katello::RepositoryOstreeBranch", :dependent => :delete_all
     has_many :ostree_branches, :through => :repository_ostree_branches
 
@@ -646,6 +648,10 @@ module Katello
       ::Host.joins(:content_facet => :bound_repositories).where("#{Katello::Repository.table_name}.id" => (self.clones.pluck(:id) + [self.id]))
     end
 
+    def docker_meta_tag_count
+      DockerMetaTag.in_repositories(self.id).count
+    end
+
     protected
 
     def removable_unit_association
@@ -704,7 +710,9 @@ module Katello
 
     def remove_docker_content(manifests)
       self.docker_tags.where(:docker_manifest_id => manifests.map(&:id)).destroy_all
+      DockerMetaTag.cleanup_tags
       self.docker_manifests -= manifests
+
       # destroy any orphan docker manifests
       manifests.each do |manifest|
         manifest.destroy if manifest.repositories.empty?

data/app/models/katello/sync_plan.rb

@@ -54,7 +54,7 @@ module Katello
     end
 
     def plan_date_time
-      self.sync_date.strftime('%Y/%m/%d %H:%M:%S %Z')
+      self.sync_date.strftime('%Y/%m/%d %H:%M:%S %z')
     end
 
     def schedule_format
@@ -105,7 +105,7 @@ module Katello
     end
 
     def next_sync
-      next_sync_date.try(:strftime, '%Y/%m/%d %H:%M:%S %Z')
+      next_sync_date.try(:strftime, '%Y/%m/%d %H:%M:%S %z')
     end
 
     def self.humanize_class_name(_name = nil)