katello 3.6.0.1.rc2 → 3.7.0.rc1

data/app/models/katello/content_view_component.rb

@@ -1,5 +1,6 @@
 module Katello
   class ContentViewComponent < Katello::Model
+    audited :associated_with => :composite_content_view
     belongs_to :composite_content_view, :class_name => "Katello::ContentView",
                               :inverse_of => :content_view_components
     belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion",

data/app/models/katello/content_view_docker_filter_rule.rb

@@ -1,7 +1,6 @@
 module Katello
   class ContentViewDockerFilterRule < Katello::Model
     include ::Katello::Concerns::ContentViewFilterRuleCommon
-
     belongs_to :filter,
                :class_name => "Katello::ContentViewDockerFilter",
                :inverse_of => :docker_rules,

data/app/models/katello/content_view_environment.rb

@@ -1,5 +1,6 @@
 module Katello
   class ContentViewEnvironment < Katello::Model
+    audited :associated_with => :content_view
     include ForemanTasks::Concerns::ActionSubject
     include Glue::Candlepin::Environment if SETTINGS[:katello][:use_cp]
     include Glue if SETTINGS[:katello][:use_cp]
@@ -8,11 +9,12 @@ module Katello
     belongs_to :content_view, :class_name => "Katello::ContentView", :inverse_of => :content_view_environments
     belongs_to :environment, :class_name => "Katello::KTEnvironment", :inverse_of => :content_view_environments
     belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion",
-                                      :inverse_of => :content_view_environments
+               :inverse_of => :content_view_environments
 
     validates_lengths_from_database
     validates :environment_id, uniqueness: {scope: :content_view_id}, presence: true
     validates :content_view_id, presence: true
+    validates_with Validators::ContentViewEnvironmentOrgValidator
 
     before_save :generate_info
 
@@ -43,10 +45,10 @@ module Katello
 
       if content_view.default?
         self.label ||= environment.label
-        self.cp_id ||= Katello::Util::Data.md5hash(environment.organization.label)
+        self.cp_id ||= Katello::Util::Data.hexdigest(environment.organization.label)
       else
         self.label ||= [environment.label, content_view.label].join('/')
-        self.cp_id ||= Katello::Util::Data.md5hash([environment.id, content_view.id].join('-'))
+        self.cp_id ||= Katello::Util::Data.hexdigest([environment.id, content_view.id].join('-'))
       end
     end
   end

data/app/models/katello/content_view_filter.rb

@@ -1,12 +1,13 @@
 module Katello
   class ContentViewFilter < Katello::Model
+    audited :associations => [:repositories]
     DOCKER = 'docker'.freeze
     RPM = Rpm::CONTENT_TYPE
     PACKAGE_GROUP   = PackageGroup::CONTENT_TYPE
     ERRATA          = Erratum::CONTENT_TYPE
     DEB             = Deb::CONTENT_TYPE
     CONTENT_TYPES   = [RPM, PACKAGE_GROUP, ERRATA, DOCKER, DEB].freeze
-    CONTENT_OPTIONS = { _('Packages') => RPM, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Docker') => DOCKER, _('deb Packages') => DEB }.freeze
+    CONTENT_OPTIONS = { _('Packages') => RPM, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Container Images') => DOCKER, _('deb Packages') => DEB }.freeze
 
     belongs_to :content_view,
                :class_name => "Katello::ContentView",

data/app/models/katello/content_view_history.rb

@@ -5,6 +5,9 @@ module Katello
     belongs_to :environment, :class_name => "Katello::KTEnvironment", :inverse_of => :content_view_histories,
                              :foreign_key => :katello_environment_id
     belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion", :foreign_key => :katello_content_view_version_id, :inverse_of => :history
+
+    belongs_to :triggered_by, :class_name => "Katello::ContentViewVersion", :inverse_of => :triggered_histories
+
     belongs_to :task, :class_name => "ForemanTasks::Task::DynflowTask", :foreign_key => :task_id
 
     IN_PROGRESS = 'in progress'.freeze

data/app/models/katello/content_view_puppet_environment.rb

@@ -54,6 +54,18 @@ module Katello
       environment
     end
 
+    def ssl_client_cert
+      false
+    end
+
+    def ssl_client_key
+      false
+    end
+
+    def ssl_ca_cert
+      false
+    end
+
     def organization
       if self.environment
         self.environment.organization

data/app/models/katello/content_view_puppet_module.rb

@@ -1,5 +1,6 @@
 module Katello
   class ContentViewPuppetModule < Katello::Model
+    audited :associated_with => :content_view
     belongs_to :content_view, :class_name => "Katello::ContentView", :inverse_of => :content_view_versions
 
     validates_lengths_from_database

data/app/models/katello/content_view_version.rb

@@ -3,6 +3,8 @@ module Katello
     include Authorization::ContentViewVersion
     include ForemanTasks::Concerns::ActionSubject
 
+    define_model_callbacks :promote, :only => [:before, :after]
+    audited :associations => [:repositories, :environments]
     before_destroy :validate_destroyable!
 
     belongs_to :content_view, :class_name => "Katello::ContentView", :inverse_of => :content_view_versions
@@ -15,12 +17,17 @@ module Katello
 
     has_many :history, :class_name => "Katello::ContentViewHistory", :inverse_of => :content_view_version,
                        :dependent => :destroy, :foreign_key => :katello_content_view_version_id
+
+    has_many :triggered_histories, :class_name => "Katello::ContentViewHistory", :dependent => :destroy,
+             :inverse_of => :triggered_by, :foreign_key => :triggered_by_id
+
     has_many :repositories, :class_name => "Katello::Repository", :dependent => :destroy
     has_many :content_view_puppet_environments, :class_name => "Katello::ContentViewPuppetEnvironment",
                                                 :dependent => :destroy
     has_one :task_status, :class_name => "Katello::TaskStatus", :as => :task_owner, :dependent => :destroy
 
-    has_many :content_view_components, :inverse_of => :content_view_version, :dependent => :destroy
+    has_many :content_view_components, :class_name => "Katello::ContentViewComponent",
+             :inverse_of => :content_view_version, :dependent => :destroy
     has_many :composite_content_views, :through => :content_view_components, :source => :composite_content_view
 
     has_many :content_view_version_components, :inverse_of => :composite_version, :dependent => :destroy, :foreign_key => :composite_version_id,
@@ -43,6 +50,11 @@ module Katello
       joins(:content_view).where("#{Katello::ContentView.table_name}.organization_id" => organization_id)
     end
 
+    scope :triggered_by, ->(content_view_version_id) do
+      sql = Katello::ContentViewHistory.where(:triggered_by_id => content_view_version_id).select(:katello_content_view_version_id).to_sql
+      where("#{Katello::ContentViewVersion.table_name}.id in (#{sql})")
+    end
+
     scoped_search :on => :content_view_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :major, :rename => :version, :complete_value => true, :ext_method => :find_by_version
     scoped_search :relation => :repositories, :on => :name, :rename => :repository, :complete_value => true
@@ -314,6 +326,7 @@ module Katello
     def check_ready_to_promote!(to_env)
       fail _("Default content view versions cannot be promoted") if default?
       content_view.check_composite_action_allowed!(to_env)
+      content_view.check_docker_repository_names!(to_env)
     end
 
     def validate_destroyable!(skip_environment_check = false)
@@ -348,5 +361,9 @@ module Katello
     def related_resources
       [self.content_view]
     end
+
+    class Jail < ::Safemode::Jail
+      allow :name, :label, :version
+    end
   end
 end

data/app/models/katello/docker_manifest.rb

@@ -2,7 +2,8 @@ module Katello
   class DockerManifest < Katello::Model
     include Concerns::PulpDatabaseUnit
     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 :repository_docker_manifests, :class_name => "Katello::RepositoryDockerManifest",
+             :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",

data/app/models/katello/docker_manifest_list.rb

@@ -3,7 +3,8 @@ module Katello
     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 :repository_docker_manifest_lists, :class_name => "Katello::RepositoryDockerManifestList",
+             :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",

data/app/models/katello/docker_meta_tag.rb

@@ -13,7 +13,28 @@ module Katello
     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
+                  :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 => ["="]
+
+    def self.meta_tags_by_digest_query(operator, digest, manifest_klass)
+      search = "digest #{operator} ?"
+      query = DockerMetaTag.search_in_tags(DockerTag.where(:docker_taggable_type => manifest_klass.name,
+                                                           :docker_taggable_id => manifest_klass.where(search, digest))).select(:id).to_sql
+      "#{DockerMetaTag.table_name}.id in (#{query})"
+    end
+
+    def self.find_by_digest(_key, operator, value)
+      if operator == '='
+        conditions = meta_tags_by_digest_query(operator, value, DockerManifest) + " OR " + meta_tags_by_digest_query(operator, value, DockerManifestList)
+      else
+        #failure condition. No such value so must return 0
+        conditions = "1=0"
+      end
+      { :conditions => conditions }
+    end
 
     def self.find_by_schema_version(_key, operator, value)
       conditions = ""

data/app/models/katello/erratum.rb

@@ -2,11 +2,11 @@ module Katello
   class Erratum < Katello::Model
     include Concerns::PulpDatabaseUnit
 
-    SECURITY = "security".freeze
-    BUGZILLA = "bugfix".freeze
-    ENHANCEMENT = "enhancement".freeze
+    SECURITY = ["security"].freeze
+    BUGZILLA = ["bugfix", "recommended"].freeze
+    ENHANCEMENT = ["enhancement", "optional"].freeze
 
-    TYPES = [SECURITY, BUGZILLA, ENHANCEMENT].freeze
+    TYPES = [SECURITY, BUGZILLA, ENHANCEMENT].flatten.freeze
     CONTENT_TYPE = Pulp::Erratum::CONTENT_TYPE
 
     has_many :content_facet_errata, :class_name => "Katello::ContentFacetErratum", :dependent => :destroy, :inverse_of => :content_facet
@@ -82,7 +82,7 @@ module Katello
     def hosts_available(org_id = nil)
       self.hosts_applicable(org_id).joins("INNER JOIN #{Katello::RepositoryErratum.table_name} on \
         #{Katello::RepositoryErratum.table_name}.erratum_id = #{self.id}").joins(:content_facet_repositories).
-        where("#{Katello::ContentFacetRepository.table_name}.repository_id = #{Katello::RepositoryErratum.table_name}.repository_id").uniq
+        where("#{Katello::ContentFacetRepository.table_name}.repository_id = #{Katello::RepositoryErratum.table_name}.repository_id")
     end
 
     def self.installable_for_hosts(hosts = nil)
@@ -118,6 +118,10 @@ module Katello
       keys = %w(title id severity issued type description reboot_suggested solution updated summary)
       custom_json = json.slice(*keys)
 
+      # handle SUSE epoch dates
+      custom_json["issued"] = convert_date_if_epoch(custom_json["issued"])
+      custom_json["updated"] = convert_date_if_epoch(custom_json["updated"]) unless custom_json["updated"].blank?
+
       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')
@@ -145,6 +149,14 @@ module Katello
 
     private
 
+    def convert_date_if_epoch(date)
+      date.to_i.to_s == date ? epoch_to_date(date) : date
+    end
+
+    def epoch_to_date(epoch)
+      Time.at(epoch.to_i).to_s
+    end
+
     def run_until(needed_function, action_function)
       needed = needed_function.call
       retries = needed.length

data/app/models/katello/event.rb

@@ -1,6 +1,8 @@
 module Katello
   class Event < Katello::Model
     validate :validate_event_type
+    # Note: Do not use active record call backs or dependent references on this class
+    # Direct deletes are made in EventQueue#clear_events (instead of destroys).
 
     def validate_event_type
       unless EventQueue.supported_event_types.include?(self.event_type)

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

@@ -49,7 +49,7 @@ module Katello
       def subscribe(pool_id, quantity = 1)
         pool = Katello::Pool.with_identifier(pool_id)
         subscription = pool.subscription
-        add_custom_product(subscription.product_id) unless subscription.redhat?
+        add_custom_product(subscription.cp_id) unless subscription.redhat?
         Resources::Candlepin::ActivationKey.add_pools self.cp_id, pool.cp_id, quantity
         self.import_pools
       end
@@ -58,7 +58,7 @@ module Katello
         fail _("Subscription id is nil.") unless pool_id
         pool = Katello::Pool.with_identifier(pool_id)
         subscription = pool.subscription
-        remove_custom_product(subscription.product_id) unless subscription.redhat?
+        remove_custom_product(subscription.cp_id) unless subscription.redhat?
         Resources::Candlepin::ActivationKey.remove_pools self.cp_id, pool.cp_id
         self.import_pools
       end

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

@@ -10,14 +10,15 @@ module Katello
       end
 
       def get_candlepin_ids(organization)
-        self.get_for_owner(organization).map { |subscription| subscription["id"] }
+        self.get_for_owner(organization.label).map { |subscription| subscription["id"] }
       end
 
       def import_candlepin_ids(organization)
         candlepin_ids = self.get_candlepin_ids(organization)
         candlepin_ids.each do |cp_id|
-          self.where(:cp_id => cp_id).first_or_create unless cp_id.nil?
+          self.where(:cp_id => cp_id, :organization_id => organization.id).first_or_create unless cp_id.nil?
         end
+        candlepin_ids
       end
 
       def with_identifier(ids)
@@ -35,13 +36,13 @@ module Katello
         organizations = organization ? [organization] : Organization.all
 
         organizations.each do |org|
-          import_candlepin_ids(org.label)
-          candlepin_ids = get_candlepin_ids(org.label)
+          candlepin_ids = import_candlepin_ids(org)
 
-          objects = self.in_organization(org) + self.where(:cp_id => candlepin_ids)
-          objects.uniq.each do |item|
+          objects = self.in_organization(org)
+          objects.each do |item|
             if candlepin_ids.include?(item.cp_id)
               item.import_data
+              item.import_managed_associations if item.respond_to?(:import_managed_associations)
             else
               item.destroy
             end

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

@@ -21,9 +21,10 @@ module Katello
       end
 
       def owner_details
-        details = Resources::Candlepin::Owner.find self.label
-        details['virt_who'] = self.subscriptions.using_virt_who.any?
-        details
+        @owner_details ||= Resources::Candlepin::Owner.find self.label
+        @owner_details['virt_who'] ||= self.subscriptions.using_virt_who.any?
+
+        @owner_details
       end
 
       def service_level

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

@@ -9,16 +9,18 @@ module Katello
         lazy_accessor :pool_facts, :initializer => lambda { |_s| self.import_lazy_attributes }
         lazy_accessor :subscription_facts, :initializer => lambda { |_s| self.subscription ? self.subscription.attributes : {} }
 
-        lazy_accessor :pool_derived, :owner, :source_pool_id, :virt_limit, :arch, :description,
-          :product_family, :variant, :suggested_quantity, :support_type, :product_id, :type,
+        lazy_accessor :pool_derived, :owner, :source_pool_id, :virt_limit, :arch, :description, :upstream_pool_id,
+          :product_family, :variant, :suggested_quantity, :support_type, :product_id, :type, :upstream_entitlement_id,
           :initializer => :pool_facts
 
-        lazy_accessor :name, :support_level, :org, :sockets, :cores, :stacking_id, :instance_multiplier,
+        lazy_accessor :name, :support_level, :org, :sockets, :cores, :instance_multiplier,
           :initializer => :subscription_facts
 
         lazy_accessor :active, :initializer => lambda { |_s| self.pool_facts["activeSubscription"] }
 
         lazy_accessor :available, :initializer => lambda { |_s| self.quantity_available }
+
+        lazy_accessor :backend_data, :initializer => lambda { |_s| self.class.candlepin_data(self.cp_id) }
       end
     end
 
@@ -63,9 +65,11 @@ module Katello
         end
 
         json["product_id"] = json["productId"] if json["productId"]
+        json["upstream_entitlement_id"] = json["upstreamEntitlementId"]
+        json["upstream_pool_id"] = json["upstreamPoolId"]
 
         if self.subscription
-          subscription.backend_data["product"]["attributes"].map { |attr| json[attr["name"].underscore.to_sym] = attr["value"] }
+          subscription.backend_data["attributes"].map { |attr| json[attr["name"].underscore.to_sym] = attr["value"] }
         end
         json
       end
@@ -77,24 +81,22 @@ module Katello
         providers.any?
       end
 
-      def backend_data
-        self.class.candlepin_data(self.cp_id)
-      end
-
       def stacking_subscription(org_label, stacking_id)
         org = Organization.find_by(:label => org_label)
         subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :product_id => stacking_id)
         if subscription.nil?
           found_product = ::Katello::Resources::Candlepin::Product.find_for_stacking_id(org_label, stacking_id)
-          subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :product_id => found_product['id']) if found_product
+          subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => found_product['id']) if found_product
         end
         subscription
       end
 
       # rubocop:disable MethodLength
-      def import_data(index_hosts = true)
+      def import_data(index_hosts = false)
         pool_attributes = {}.with_indifferent_access
         pool_json = self.backend_data
+
+        self.organization ||= Organization.find_by(:label => pool_json['owner']['key'])
         product_attributes = pool_json["productAttributes"] + pool_json["attributes"]
 
         product_attributes.map { |attr| pool_attributes[attr["name"].underscore.to_sym] = attr["value"] }
@@ -102,7 +104,7 @@ module Katello
         if pool_json["sourceStackId"]
           subscription = stacking_subscription(pool_json['owner']['key'], pool_json["sourceStackId"])
         else
-          subscription = ::Katello::Subscription.find_by(:cp_id => pool_json["subscriptionId"])
+          subscription = ::Katello::Subscription.find_by(:cp_id => pool_json["productId"])
         end
 
         pool_attributes[:subscription_id] = subscription.id if subscription
@@ -135,24 +137,52 @@ module Katello
           pool_attributes[:virt_who] = false
         end
 
+        pool_attributes['stack_id'] = pool_json['stackId']
         exceptions = pool_attributes.keys.map(&:to_sym) - self.attribute_names.map(&:to_sym)
         self.update_attributes(pool_attributes.except!(*exceptions))
         self.save!
         self.create_activation_key_associations
+        self.create_product_associations
         self.import_hosts if index_hosts
       end
 
+      def create_product_associations
+        products = self.backend_data["providedProducts"] + self.backend_data["derivedProvidedProducts"]
+        cp_product_ids = products.map { |product| product["productId"] }
+        cp_product_ids << self.subscription.cp_id if self.subscription
+
+        cp_product_ids.each do |cp_id|
+          product = ::Katello::Product.where(:cp_id => cp_id, :organization_id => self.organization.id)
+          if product.any?
+            ::Katello::Util::Support.active_record_retry do
+              ::Katello::PoolProduct.where(:pool_id => self.id, :product_id => product.first.id).first_or_create
+            end
+          end
+        end
+      end
+
       def import_hosts
         entitlements = Resources::Candlepin::Pool.entitlements(self.cp_id, ["consumer.uuid"])
         uuids = entitlements.map { |ent| ent["consumer"]["uuid"] }
-        sub_facets = Katello::Host::SubscriptionFacet.where(:uuid => uuids)
-        sub_facet_ids = sub_facets.pluck(:id)
-        sub_facet_ids.each do |sub_facet_id|
-          Katello::SubscriptionFacetPool.where(:pool_id => self.id, :subscription_facet_id => sub_facet_id).first_or_create
-        end
-        existing_associations = Katello::SubscriptionFacetPool.where(:pool_id => self.id)
-        correct_associations = Katello::SubscriptionFacetPool.where(:pool_id => self.id, :subscription_facet_id => sub_facet_ids)
-        (existing_associations - correct_associations).map(&:destroy)
+
+        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)
+        entries_to_add = sub_facet_ids_from_cp - sub_facet_ids_from_pool_table
+        unless entries_to_add.empty?
+          ActiveRecord::Base.transaction do
+            entries_to_add.each do |sub_facet_id|
+              query = "INSERT INTO #{Katello::SubscriptionFacetPool.table_name} (pool_id, subscription_facet_id) VALUES (#{self.id}, #{sub_facet_id})"
+              ActiveRecord::Base.connection.execute(query)
+            end
+          end
+        end
+
+        entries_to_remove = sub_facet_ids_from_pool_table - sub_facet_ids_from_cp
+        Katello::SubscriptionFacetPool.where(:pool_id => self.id, :subscription_facet_id => entries_to_remove).delete_all
+      end
+
+      def import_managed_associations
+        import_hosts
       end
 
       def hosts
@@ -171,7 +201,8 @@ module Katello
       end
 
       def hypervisor
-        ::Host.find_by(id: self.hypervisor_id) if self.hypervisor_id
+        host = ::Host.unscoped.find_by(id: self.hypervisor_id) if self.hypervisor_id
+        return host if (host && host.authorized?(:view_hosts))
       end
     end
   end