katello 3.7.0.rc1 → 3.7.0.rc2

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

@@ -27,6 +27,8 @@ module Katello
         has_many :host_collection_hosts, :class_name => "::Katello::HostCollectionHosts", :foreign_key => :host_id, :dependent => :destroy
         has_many :host_collections, :class_name => "::Katello::HostCollection", :through => :host_collection_hosts
 
+        has_many :hypervisor_pools, :class_name => '::Katello::Pool', :foreign_key => :hypervisor_id, :dependent => :nullify
+
         before_save :correct_puppet_environment
 
         scoped_search :relation => :host_collections, :on => :id, :complete_value => false, :rename => :host_collection_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER

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

@@ -24,6 +24,7 @@ module Katello
         has_many :gpg_keys, :class_name => "Katello::GpgKey", :dependent => :destroy, :inverse_of => :organization
         has_many :sync_plans, :class_name => "Katello::SyncPlan", :dependent => :destroy, :inverse_of => :organization
         has_many :host_collections, :class_name => "Katello::HostCollection", :dependent => :destroy, :inverse_of => :organization
+        has_many :contents, :class_name => "Katello::Content", :dependent => :destroy, :inverse_of => :organization
         has_many :content_views, :class_name => "Katello::ContentView", :dependent => :destroy, :inverse_of => :organization
         has_many :content_view_environments, :through => :content_views
         has_many :task_statuses, :class_name => "Katello::TaskStatus", :dependent => :destroy, :as => :task_owner

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

@@ -16,6 +16,16 @@ module Katello
 
         prepend ForemanTasks::Concerns::ActionTriggering
 
+        module Prepended
+          def update_action
+            if subscription_facet.try(:backend_update_needed?)
+              ::Actions::Katello::Host::Update
+            end
+          end
+        end
+
+        prepend Prepended
+
         accepts_nested_attributes_for :subscription_facet, :update_only => true, :reject_if => lambda { |attrs| attrs.values.compact.empty? }
 
         has_many :activation_keys, :through => :subscription_facet
@@ -43,12 +53,6 @@ module Katello
         scoped_search :on => :id, :relation => :pools, :rename => :subscription_id, :complete_value => true, :ext_method => :find_by_subscription_id
       end
 
-      def update_action
-        if subscription_facet.try(:backend_update_needed?)
-          ::Actions::Katello::Host::Update
-        end
-      end
-
       module ClassMethods
         def find_by_activation_key(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{Katello::ActivationKey.table_name}.name #{operator} ?", value_to_sql(operator, value)])

data/app/models/katello/content.rb

@@ -3,15 +3,36 @@ module Katello
     include Katello::Glue::Candlepin::Content
     has_many :product_contents, :class_name => 'Katello::ProductContent', :dependent => :destroy
     has_many :products, :through => :product_contents
+    belongs_to :organization, :inverse_of => :contents, :class_name => "::Organization"
 
-    validates :label, :uniqueness => true
-    validates :cp_content_id, :uniqueness => true
+    validates :label, :uniqueness => {:scope => :organization_id}
+    validates :cp_content_id, :uniqueness => {:scope => :organization_id}
 
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :content_type, :complete_value => true
     scoped_search :on => :label, :complete_value => true
     scoped_search :relation => :products, :on => :name, :rename => :product_name, :complete_value => true
 
+    after_save :update_repository_names, :if => :propagate_name_change?
+
+    def update_repository_names
+      self.repositories.each do |repo|
+        repo.update_attributes!(:name => repo.calculate_updated_name)
+      end
+    end
+
+    def repositories
+      Katello::Repository.where(:content_id => self.cp_content_id)
+    end
+
+    def redhat?
+      self.products.first.try(:redhat?)
+    end
+
+    def propagate_name_change?
+      self.saved_change_to_attribute?(:name) && self.redhat?
+    end
+
     def self.import_all
       Organization.all.each do |org|
         org.products.each do |product|

data/app/models/katello/content_view_docker_filter.rb

@@ -32,7 +32,7 @@ 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).all.collect do |tag|
+        manifest.docker_tags.where(:repository => repo).where("name ilike ?", query_name).all.collect do |tag|
           tag.uuid
         end
       end

data/app/models/katello/content_view_puppet_module.rb

@@ -5,7 +5,7 @@ module Katello
 
     validates_lengths_from_database
     validates :content_view_id, :presence => true
-    validates :name, :uniqueness => { :scope => :content_view_id }, :allow_blank => true
+    validates :name, :uniqueness => { :scope => :content_view_id, :message => _('There is already a module named "%{value}" in this content view.') }
     validates :uuid, :uniqueness => { :scope => :content_view_id }, :allow_blank => true
 
     validates_with Validators::ContentViewPuppetModuleValidator
@@ -15,6 +15,8 @@ module Katello
     scoped_search :on => :uuid, :complete_value => true
     scoped_search :on => :name, :relation => :content_view, :rename => :content_view_name
 
+    before_validation :set_attributes
+
     def puppet_module
       PuppetModule.find_by_uuid(self.uuid)
     end
@@ -38,8 +40,6 @@ module Katello
       self.computed_version.eql?(latest_from_list.try(:version))
     end
 
-    before_save :set_attributes
-
     private
 
     def set_attributes

data/app/models/katello/content_view_version.rb

@@ -277,6 +277,10 @@ module Katello
       ::Katello::DockerMetaTag.where(:repository_id => repositories.archived.docker_type).count
     end
 
+    def docker_tags
+      ::Katello::DockerMetaTag.where(:repository_id => repositories.docker_type)
+    end
+
     def debs
       Katello::Deb.in_repositories(self.repositories.archived)
     end

data/app/models/katello/environment_prior.rb

@@ -0,0 +1,7 @@
+module Katello
+  class EnvironmentPrior < Katello::Model
+    belongs_to :env, :class_name => "Katello::KTEnvironment", :inverse_of => :env_priors, :foreign_key => :environment_id
+    belongs_to :env_prior, :class_name => "Katello::KTEnvironment", :inverse_of => :env_successors, :foreign_key => :prior_id
+    validates :prior_id, :presence => true
+  end
+end

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

@@ -32,7 +32,7 @@ module Katello
         where("#{self.table_name}.id = (?) or #{self.table_name}.cp_id = (?)", id_integers, ids)
       end
 
-      def import_all(organization = nil)
+      def import_all(organization = nil, import_managed_associations = true)
         organizations = organization ? [organization] : Organization.all
 
         organizations.each do |org|
@@ -42,7 +42,7 @@ module Katello
           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)
+              item.import_managed_associations if import_managed_associations && item.respond_to?(:import_managed_associations)
             else
               item.destroy
             end

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

@@ -9,8 +9,8 @@ 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, :upstream_pool_id,
-          :product_family, :variant, :suggested_quantity, :support_type, :product_id, :type, :upstream_entitlement_id,
+        lazy_accessor :pool_derived, :owner, :source_pool_id, :virt_limit, :arch, :description, :product_family,
+          :variant, :suggested_quantity, :support_type, :product_id, :type, :upstream_entitlement_id,
           :initializer => :pool_facts
 
         lazy_accessor :name, :support_level, :org, :sockets, :cores, :instance_multiplier,
@@ -66,7 +66,6 @@ module Katello
 
         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["attributes"].map { |attr| json[attr["name"].underscore.to_sym] = attr["value"] }
@@ -91,8 +90,8 @@ module Katello
         subscription
       end
 
-      # rubocop:disable MethodLength
-      def import_data(index_hosts = false)
+      # rubocop:disable MethodLength,Metrics/AbcSize
+      def import_data(index_hosts_and_activation_keys = false)
         pool_attributes = {}.with_indifferent_access
         pool_json = self.backend_data
 
@@ -113,6 +112,7 @@ module Katello
           pool_attributes[json_attribute.underscore] = pool_json[json_attribute]
         end
         pool_attributes[:pool_type] = pool_json["type"] if pool_json.key?("type")
+        pool_attributes[:upstream_pool_id] = pool_json["upstreamPoolId"] if pool_json.key?("upstreamPoolId")
 
         if pool_attributes.key?(:multi_entitlement)
           pool_attributes[:multi_entitlement] = pool_attributes[:multi_entitlement] == "yes"
@@ -141,10 +141,11 @@ module Katello
         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_activation_key_associations if index_hosts_and_activation_keys
         self.create_product_associations
-        self.import_hosts if index_hosts
+        self.import_hosts if index_hosts_and_activation_keys
       end
+      # rubocop:enable MethodLength,Metrics/AbcSize
 
       def create_product_associations
         products = self.backend_data["providedProducts"] + self.backend_data["derivedProvidedProducts"]
@@ -183,6 +184,7 @@ module Katello
 
       def import_managed_associations
         import_hosts
+        create_activation_key_associations
       end
 
       def hosts
@@ -190,7 +192,7 @@ module Katello
       end
 
       def create_activation_key_associations
-        keys = Resources::Candlepin::ActivationKey.get(nil, "?include=id&include=pools.pool.id")
+        keys = Resources::Candlepin::ActivationKey.get(nil, "?include=id&include=pools.pool.id", organization.label)
         activation_key_ids = keys.collect do |key|
           key['id'] if key['pools'].present? && key['pools'].any? { |pool| pool['pool'].try(:[], 'id') == cp_id }
         end
@@ -199,11 +201,6 @@ module Katello
           Katello::PoolActivationKey.where(:activation_key_id => key.id, :pool_id => self.id).first_or_create
         end
       end
-
-      def hypervisor
-        host = ::Host.unscoped.find_by(id: self.hypervisor_id) if self.hypervisor_id
-        return host if (host && host.authorized?(:view_hosts))
-      end
     end
   end
 end

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

@@ -32,14 +32,22 @@ module Katello
       name.gsub(/[^a-z0-9\-_ ]/i, "")
     end
 
-    def self.import_from_cp(attrs = nil, &block)
+    def self.engineering_product_id?(id)
+      id.match(/^\d+$/) #engineering products are numeric
+    end
+
+    def self.import_from_cp(attrs, organization)
       product_content_attrs = attrs.delete(:productContent) || []
       import_logger = attrs[:import_logger]
 
-      attrs = attrs.merge('name' => validate_name(attrs['name']), 'label' => Util::Model.labelize(attrs['name']))
+      product_attrs = {'name' => validate_name(attrs['name']),
+                       'cp_id' => attrs['id'],
+                       'label' => Util::Model.labelize(attrs['name']),
+                       'multiplier' => attrs['multiplier'],
+                       'organization_id' => organization.id,
+                       'provider_id' => organization.redhat_provider.id}
 
-      product = Product.new(attrs, &block)
-      product.save!
+      product = Product.create!(product_attrs)
       import_product_content(product, product_content_attrs)
     rescue => e
       [Rails.logger, import_logger].each do |logger|
@@ -60,16 +68,18 @@ module Katello
           content_type: pc[:type],
           vendor: pc[:vendor],
           gpg_url: pc[:gpgUrl],
-          content_url: pc[:contentUrl]
+          content_url: pc[:contentUrl],
+          organization_id: product.organization_id
         }
 
-        # current product has this content - update it
+        # current product has this content - update its name if needed
         # 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'])
+          new_name = pc['name']
+          existing.content.update_attributes!(:name => new_name) if existing.content.name != new_name
+          existing.update_attributes!(enabled: params['enabled']) if existing.enabled != params['enabled']
         else
-          content = ::Katello::Content.find_by_cp_content_id(pc[:id])
+          content = ::Katello::Content.where(:cp_content_id => pc[:id], :organization_id => product.organization_id).first
           content ||= ::Katello::Content.create!(content_attrs)
 
           ::Katello::ProductContent.create!(enabled: params[:enabled],

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

@@ -10,6 +10,22 @@ 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 != '')

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

@@ -18,7 +18,7 @@ module Katello
       def get_for_owner(organization)
         Katello::Resources::Candlepin::Product.all(organization).select do |product|
           #this product's id is non-numeric (marketing product), or its a custom product
-          product['id'].to_i.to_s != product['id'] || Katello::Product.find_by(:cp_id => product['id']).try(:custom?)
+          !Glue::Candlepin::Product.engineering_product_id?(product['id']) || Katello::Product.find_by(:cp_id => product['id']).try(:custom?)
         end
       end
     end

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

@@ -123,68 +123,28 @@ module Katello
         ::Foreman::Logging.logger('katello/manifest_import_logger')
       end
 
-      def update_product_content_from_cp(katello_and_cp_ids)
-        katello_and_cp_ids.each do |id_pair|
-          attrs = Resources::Candlepin::Product.get(self.organization.label, id_pair.second, %w(productContent)).first
-          product_content_attrs = attrs.delete(:productContent) || []
-          product = ::Katello::Product.find(id_pair.first)
-          Glue::Candlepin::Product.import_product_content(product, product_content_attrs)
-        end
-      end
-
-      # TODO: break up method
-      def import_products_from_cp # rubocop:disable MethodLength
-        db_and_cp_ids = self.organization.providers.redhat.first.products.pluck(:id, :cp_id)
-
-        # this method only imports products which are not already in Katello
-        # no need for a full import on them - just update the product content
-        update_product_content_from_cp(db_and_cp_ids)
-
-        product_in_katello_ids = db_and_cp_ids.map(&:second)
-        products_in_candlepin_ids = []
-
-        marketing_to_engineering_product_ids_mapping.each do |marketing_product_id, engineering_product_ids|
-          engineering_product_ids = engineering_product_ids.uniq
-          products_in_candlepin_ids << marketing_product_id
-          products_in_candlepin_ids.concat(engineering_product_ids)
-          added_eng_products = (engineering_product_ids - product_in_katello_ids).map do |id|
-            Resources::Candlepin::Product.get(self.organization.label, id)[0]
-          end
-          adjusted_eng_products = []
-          added_eng_products.each do |product_attrs|
-            begin
-              Glue::Candlepin::Product.import_from_cp(product_attrs) do |p|
-                p.provider = self
-                p.organization_id = self.organization.id
-              end
-              adjusted_eng_products << product_attrs
-              import_logger.info "import of product '#{product_attrs["name"]}' from Candlepin OK"
-            rescue Errors::SecurityViolation => e
-              # Do not add non-accessible products
-              logger.info "import of product '#{product_attrs["name"]}' from Candlepin failed"
-              import_logger.info e
-            end
-          end
-
-          product_in_katello_ids.concat(adjusted_eng_products.map { |p| p["id"] })
-
-          marketing_product = Katello::Product.find_by_cp_id(marketing_product_id)
-          marketing_product.destroy if marketing_product && marketing_product.redhat?
-        end
+      def import_products_from_cp
+        cp_products = ::Katello::Resources::Candlepin::Product.all(organization.label, [:id, :name, :multiplier, :productContent])
+        cp_products = cp_products.select { |prod| Glue::Candlepin::Product.engineering_product_id?(prod['id']) }
 
-        product_to_remove_ids = (product_in_katello_ids - products_in_candlepin_ids).uniq
-        product_to_remove_ids.each do |cp_id|
-          product = Product.find_by_cp_id(cp_id, self.organization)
-          Rails.logger.warn "Orphaned Product id #{product.id} found while refreshing/importing manifest."
-        end
+        cp_products.each { |product| import_product(product) }
 
         self.index_subscriptions(self.organization)
-        true
+      end
+
+      def import_product(cp_product)
+        product = organization.products.find_by(:cp_id => cp_product['id'])
+        if product && product.redhat?
+          product.update_attributes!(:name => cp_product['name']) unless product.name == cp_product['name']
+          Glue::Candlepin::Product.import_product_content(product, cp_product['productContent'])
+        elsif product.nil?
+          Glue::Candlepin::Product.import_from_cp(cp_product, organization)
+        end
       end
 
       def index_subscriptions(organization = nil)
         Katello::Subscription.import_all(organization)
-        Katello::Pool.import_all(organization)
+        Katello::Pool.import_all(organization, false)
       end
 
       def rules_source
@@ -197,32 +157,6 @@ module Katello
 
       protected
 
-      # When a subscription is defined as a virtual data center subscription,
-      # its pools will have a seperate 'derived' marketing product and a seperate set
-      # of 'derived' engineering products. These products become the marketing and
-      # engineering products for the sub pool once a host binds to the original pool.
-      # We need to make sure to include these 'derived' products when creating our mapping.
-      def marketing_to_engineering_product_ids_mapping
-        mapping = {}
-        pools = Resources::Candlepin::Owner.pools self.organization.label
-        pools.each do |pool|
-          mapping[pool[:productId]] ||= []
-          if pool[:providedProducts]
-            eng_product_ids = pool[:providedProducts].map { |provided| provided[:productId] }
-            mapping[pool[:productId]].concat(eng_product_ids)
-          end
-          # Check to see if there are any 'derived' products defined.
-          if pool[:derivedProductId]
-            mapping[pool[:derivedProductId]] ||= []
-            if pool[:derivedProvidedProducts]
-              eng_product_ids = pool[:derivedProvidedProducts].map { |provided| provided[:productId] }
-              mapping[pool[:derivedProductId]].concat(eng_product_ids)
-            end
-          end
-        end
-        mapping
-      end
-
       def candlepin_ping
         @candlepin_ping ||= Resources::Candlepin::CandlepinPing.ping
       end

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

@@ -1,7 +1,7 @@
 module Katello
   module Host
     class SubscriptionFacet < Katello::Model
-      audited :associations => [:pools]
+      audited :associations => [:pools], :except => [:last_checkin]
       self.table_name = 'katello_subscription_facets'
       include Facets::Base