katello 3.6.0.1.rc2 → 3.7.0.rc1

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

@@ -149,10 +149,11 @@ module Katello
         self.productContent << content
       end
 
-      def import_subscription(subscription_id)
+      def import_custom_subscription
+        fail _("Cannot import a custom subscription from a redhat product.") if self.redhat?
         sub = nil
         ::Katello::Util::Support.active_record_retry do
-          sub = ::Katello::Subscription.where(:cp_id => subscription_id).first_or_create
+          sub = ::Katello::Subscription.where(:cp_id => self.cp_id, :organization_id => self.organization.id).first_or_create
         end
         sub.import_data
         pools = ::Katello::Resources::Candlepin::Product.pools(self.organization.label, self.cp_id)

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

@@ -1,59 +1,40 @@
 module Katello
   module Glue::Candlepin::Subscription
     def self.included(base)
+      base.send :include, LazyAccessor
       base.send :include, InstanceMethods
       base.send :extend, ClassMethods
+
+      base.class_eval do
+        lazy_accessor :backend_data, :initializer => lambda { |_s| self.class.candlepin_data(self.organization.label, self.cp_id) }
+      end
     end
 
     module ClassMethods
-      def candlepin_data(cp_id)
-        Katello::Resources::Candlepin::Subscription.get(cp_id)
+      def candlepin_data(org, cp_id)
+        Katello::Resources::Candlepin::Product.get(org, cp_id)[0]
       end
 
-      def get_for_owner(organization = self.organization.label)
-        Katello::Resources::Candlepin::Subscription.get_for_owner(organization)
+      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?)
+        end
       end
     end
 
     module InstanceMethods
-      def backend_data
-        self.class.candlepin_data(self.cp_id)
-      end
-
-      def query_products
-        self.backend_data["providedProducts"] + self.backend_data["derivedProvidedProducts"]
-      end
-
       def import_data
         subscription_attributes = {}
-        subscription_json = self.backend_data
+        product_json = self.backend_data
 
-        subscription_json["product"]["attributes"].map { |attr| subscription_attributes[attr["name"].to_sym] = attr["value"] }
+        product_json["attributes"].each { |attr| subscription_attributes[attr["name"].to_sym] = attr["value"] }
 
-        subscription_attributes[:name] = subscription_json["product"]["name"]
-        subscription_attributes[:product_id] = subscription_json["product"]["id"]
-        subscription_attributes[:instance_multiplier] = subscription_json["product"]["multiplier"]
-        subscription_attributes[:stacking_id] = subscription_json["stackId"]
-        organization = Organization.find_by(:label => subscription_json["owner"]["key"]) if subscription_json["owner"]
-        subscription_attributes[:organization_id] = organization.id if organization
+        subscription_attributes[:name] = product_json["name"]
+        subscription_attributes[:instance_multiplier] = product_json["multiplier"]
 
         exceptions = subscription_attributes.keys.map(&:to_sym) - self.attribute_names.map(&:to_sym)
         self.update_attributes!(subscription_attributes.except!(*exceptions))
-        self.create_product_associations
-      end
-
-      def create_product_associations
-        products = self.query_products
-        cp_product_ids = products.map { |product| product["id"] }
-        cp_product_ids << self.product_id if self.product_id
-        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::SubscriptionProduct.where(:subscription_id => self.id, :product_id => product.first.id).first_or_create
-            end
-          end
-        end
       end
     end
   end

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

@@ -27,19 +27,31 @@ module Katello
                       :initializer => lambda { |_s| pulp_repo_facts["distributors"] if pulp_id }
 
         def self.ensure_sync_notification
+          results = {:existing => [], :deleted => []}
           resource = Katello.pulp_server.resources.event_notifier
           url = SETTINGS[:katello][:post_sync_url]
           type = Runcible::Resources::EventNotifier::EventTypes::REPO_SYNC_COMPLETE
           notifs = resource.list
 
-          #delete any similar tasks with the wrong url (in case it changed)
-          notifs.select { |n| n['event_types'] == [type] && n['notifier_config']['url'] != url }.each do |e|
-            resource.delete(e['id'])
+          # delete any similar tasks with the wrong url (in case it changed)
+          notifs.select { |n| n['event_types'] == [type] }.each do |e|
+            if e['notifier_config']['url'] != url
+              resource.delete(e['id'])
+              results[:deleted] << e
+            else
+              results[:existing] << e
+            end
           end
 
           #only create a notifier if one doesn't exist with the correct url
           exists = notifs.select { |n| n['event_types'] == [type] && n['notifier_config']['url'] == url }
-          resource.create(Runcible::Resources::EventNotifier::NotifierTypes::REST_API, {:url => url}, [type]) if exists.empty?
+
+          if exists.empty?
+            resource.create(Runcible::Resources::EventNotifier::NotifierTypes::REST_API, {:url => url}, [type])
+            results[:created] = url
+          end
+
+          results
         end
 
         def self.delete_orphaned_content
@@ -215,6 +227,7 @@ module Katello
           :download_policy => new_download_policy,
           :remove_missing => capsule.default_capsule? ? self.mirror_on_sync? : true
         }
+        config[:type_skip_list] = ignorable_content if ignorable_content
         config.merge(importer_connection_options(capsule))
       end
 
@@ -255,6 +268,12 @@ module Katello
             :ssl_ca_cert => Katello::Repository.feed_ca_cert(url),
             :proxy_host => self.proxy_host_value
           }
+        elsif self.ssl_client_cert && self.ssl_client_key && self.ssl_ca_cert
+          importer_options = {
+            :ssl_client_cert => self.ssl_client_cert.content,
+            :ssl_client_key => self.ssl_client_key.content,
+            :ssl_ca_cert => self.ssl_ca_cert.content
+          }
         else
           importer_options = {
             :ssl_client_cert => nil,
@@ -278,6 +297,7 @@ module Katello
         when Repository::YUM_TYPE
           yum_dist_id = self.pulp_id
           yum_dist_options = {:protected => true, :id => yum_dist_id, :auto_publish => true}
+          yum_dist_options[:skip] = ignorable_content if ignorable_content
           #check the instance variable, as we do not want to go to pulp
           yum_dist_options['checksum_type'] = self.checksum_type
           yum_dist = Runcible::Models::YumDistributor.new(self.relative_path, self.unprotected, true,
@@ -424,8 +444,8 @@ module Katello
 
       def pulp_update_needed?
         changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync
-                                   upstream_username upstream_password ostree_upstream_sync_policy ostree_upstream_sync_depth ignore_global_proxy)
-        changeable_attributes << "name" if docker?
+                                   upstream_username upstream_password ostree_upstream_sync_policy ostree_upstream_sync_depth ignore_global_proxy ignorable_content)
+        changeable_attributes += %w(name container_repository_name) if docker?
         changeable_attributes += %w(deb_releases deb_components deb_architectures) if deb?
         changeable_attributes.any? { |key| previous_changes.key?(key) }
       end

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

@@ -7,9 +7,9 @@ module Katello
     end
 
     def self.repo_path_from_content_path(environment, content_path)
-      content_path = content_path.sub(/^\//, "")
-      path_prefix = [environment.organization.label, environment.label].join("/")
-      "#{path_prefix}/#{content_path}"
+      path = content_path.sub(%r|^/|, '')
+      path_prefix = [environment.organization.label, environment.label].join('/')
+      "#{path_prefix}/#{path}"
     end
 
     # repo path for custom product repos (RH repo paths are derived from
@@ -213,6 +213,9 @@ module Katello
                        :label => repo_param[:label],
                        :url => repo_param[:url],
                        :gpg_key => repo_param[:gpg_key],
+                       :ssl_ca_cert => repo_param[:ssl_ca_cert],
+                       :ssl_client_cert => repo_param[:ssl_client_cert],
+                       :ssl_client_key => repo_param[:ssl_client_key],
                        :unprotected => repo_param[:unprotected],
                        :content_type => repo_param[:content_type],
                        :checksum_type => repo_param[:checksum_type],

data/app/models/katello/gpg_key.rb

@@ -1,26 +1,47 @@
 module Katello
   class GpgKey < Katello::Model
+    audited :associations => [:products]
+
     include Katello::Authorization::GpgKey
-    MAX_CONTENT_LENGTH = 100_000
     MAX_CONTENT_LINE_LENGTH = 65
 
+    GPG_KEY_TYPE = 'gpg_key'.freeze
+    CERT_TYPE = 'cert'.freeze
+
     has_many :repositories, :class_name => "Katello::Repository", :inverse_of => :gpg_key, :dependent => :nullify
     has_many :products, :class_name => "Katello::Product", :inverse_of => :gpg_key, :dependent => :nullify
-
+    has_many :ssl_ca_products, :class_name => "Katello::Product", :foreign_key => "ssl_ca_cert_id",
+                               :inverse_of => :ssl_ca_cert, :dependent => :nullify
+    has_many :ssl_client_products, :class_name => "Katello::Product", :foreign_key => "ssl_client_cert_id",
+                                   :inverse_of => :ssl_client_cert, :dependent => :nullify
+    has_many :ssl_key_products, :class_name => "Katello::Product", :foreign_key => "ssl_client_key_id",
+                                :inverse_of => :ssl_client_key, :dependent => :nullify
+    has_many :ssl_ca_repos, :class_name => "Katello::Repository", :foreign_key => "ssl_ca_cert_id",
+                            :inverse_of => :ssl_ca_cert, :dependent => :nullify
+    has_many :ssl_client_repos, :class_name => "Katello::Repository", :foreign_key => "ssl_client_cert_id",
+                                :inverse_of => :ssl_client_cert, :dependent => :nullify
+    has_many :ssl_key_repos, :class_name => "Katello::Repository", :foreign_key => "ssl_client_key_id",
+                             :inverse_of => :ssl_client_key, :dependent => :nullify
     belongs_to :organization, :inverse_of => :gpg_keys
 
     validates_lengths_from_database
     validates :name, :presence => true, :uniqueness => {:scope => :organization_id,
                                                         :message => N_("has already been taken")}
-    validates :content, :presence => true, :length => {:maximum => MAX_CONTENT_LENGTH}
+    validates :content_type, :presence => true, :inclusion => { :in => [GPG_KEY_TYPE, CERT_TYPE],
+                                                                :message => N_("must be %{gpg_key} or %{cert}") % { :gpg_key => GPG_KEY_TYPE, :cert => CERT_TYPE} }
+    validates :content, :presence => true
     validates :organization, :presence => true
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
     validates_with Validators::ContentValidator, :attributes => :content
-    validates_with Validators::GpgKeyContentValidator, :attributes => :content, :if => proc { SETTINGS[:katello][:gpg_strict_validation] }
+    validates_with Validators::GpgKeyContentValidator, :attributes => :content, :if => :use_gpg_content_validator?
 
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :organization_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
 
+    def use_gpg_content_validator?
+      content_type == GPG_KEY_TYPE && SETTINGS[:katello][:gpg_strict_validation]
+    end
+
     def as_json(options = {})
       options ||= {}
       ret = super(options.except(:details))
@@ -34,5 +55,9 @@ module Katello
     def self.humanize_class_name(_name = nil)
       _("GPG Keys")
     end
+
+    def to_label
+      "content credential (#{content_type} - #{name})"
+    end
   end
 end

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

@@ -1,6 +1,7 @@
 module Katello
   module Host
     class ContentFacet < Katello::Model
+      audited :associated_with => :lifecycle_environment
       self.table_name = 'katello_content_facets'
       include Facets::Base
 
@@ -9,17 +10,18 @@ module Katello
       belongs_to :lifecycle_environment, :inverse_of => :content_facets, :class_name => "Katello::KTEnvironment"
       belongs_to :content_source, :class_name => "::SmartProxy", :foreign_key => :content_source_id, :inverse_of => :content_facets
 
-      has_many :content_facet_errata, :class_name => "Katello::ContentFacetErratum", :dependent => :destroy, :inverse_of => :content_facet
+      has_many :content_facet_errata, :class_name => "Katello::ContentFacetErratum", :dependent => :delete_all, :inverse_of => :content_facet
       has_many :applicable_errata, :through => :content_facet_errata, :class_name => "Katello::Erratum", :source => :erratum
 
       has_many :content_facet_repositories, :class_name => "Katello::ContentFacetRepository", :dependent => :destroy, :inverse_of => :content_facet
       has_many :bound_repositories, :through => :content_facet_repositories, :class_name => "Katello::Repository", :source => :repository
 
-      has_many :content_facet_applicable_rpms, :class_name => "Katello::ContentFacetApplicableRpm", :dependent => :destroy, :inverse_of => :content_facet
+      has_many :content_facet_applicable_rpms, :class_name => "Katello::ContentFacetApplicableRpm", :dependent => :delete_all, :inverse_of => :content_facet
       has_many :applicable_rpms, :through => :content_facet_applicable_rpms, :class_name => "Katello::Rpm", :source => :rpm
 
       validates :content_view, :presence => true, :allow_blank => false
       validates :lifecycle_environment, :presence => true, :allow_blank => false
+      validates_with Validators::AssociationExistsValidator, attributes: [:content_source]
       validates :host, :presence => true, :allow_blank => false
       validates_with Validators::ContentViewEnvironmentValidator
 
@@ -85,7 +87,7 @@ module Katello
             :installable_security_errata_count => self.installable_errata.security.count,
             :installable_bugfix_errata_count => self.installable_errata.bugfix.count,
             :installable_enhancement_errata_count => self.installable_errata.enhancement.count,
-            :applicable_rpm_count => self.applicable_rpms.count,
+            :applicable_rpm_count => self.content_facet_applicable_rpms.count,
             :upgradable_rpm_count => self.installable_rpms.count
         )
       end

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

@@ -1,6 +1,7 @@
 module Katello
   module Host
     class SubscriptionFacet < Katello::Model
+      audited :associations => [:pools]
       self.table_name = 'katello_subscription_facets'
       include Facets::Base
 
@@ -10,22 +11,30 @@ module Katello
       has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy, :inverse_of => :subscription_facet
       has_many :activation_keys, :through => :subscription_facet_activation_keys, :class_name => "Katello::ActivationKey"
 
-      has_many :subscription_facet_pools, :class_name => "Katello::SubscriptionFacetPool", :dependent => :destroy, :inverse_of => :subscription_facet
+      has_many :subscription_facet_pools, :class_name => "Katello::SubscriptionFacetPool", :dependent => :delete_all, :inverse_of => :subscription_facet
       has_many :pools, :through => :subscription_facet_pools, :class_name => "Katello::Pool"
+
+      has_many :subscription_facet_installed_products, :class_name => "Katello::SubscriptionFacetInstalledProduct", :dependent => :destroy, :inverse_of => :subscription_facet
+      has_many :installed_products, :through => :subscription_facet_installed_products, :class_name => "Katello::InstalledProduct"
+
+      has_many :compliance_reasons, :class_name => "Katello::ComplianceReason", :dependent => :destroy, :inverse_of => :subscription_facet
+
       validates :host, :presence => true, :allow_blank => false
 
       DEFAULT_TYPE = 'system'.freeze
 
-      attr_accessor :installed_products, :facts, :hypervisor_guest_uuids
+      accepts_nested_attributes_for :installed_products
+
+      attr_accessor :facts
 
       def update_from_consumer_attributes(consumer_params)
         import_database_attributes(consumer_params)
-        self.installed_products = consumer_params['installedProducts'] unless consumer_params['installedProducts'].blank?
         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
 
-      def import_database_attributes(consumer_params)
+      def import_database_attributes(consumer_params = candlepin_consumer.consumer_attributes)
+        update_subscription_status(consumer_params[:entitlementStatus]) unless consumer_params[:entitlementStatus].blank?
         update_hypervisor(consumer_params)
         update_guests(consumer_params)
 
@@ -33,6 +42,7 @@ module Katello
         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?
+        self.update_installed_products(consumer_params['installedProducts']) if consumer_params.key?('installedProducts')
 
         unless consumer_params['releaseVer'].blank?
           release = consumer_params['releaseVer']
@@ -41,6 +51,30 @@ module Katello
         end
       end
 
+      def update_installed_products(consumer_installed_product_list)
+        self.installed_products = consumer_installed_product_list.map do |consumer_installed_product|
+          InstalledProduct.find_or_create_from_consumer(consumer_installed_product)
+        end
+      end
+
+      def update_compliance_reasons(reasons)
+        reasons = Katello::Candlepin::Consumer.friendly_compliance_reasons(reasons)
+
+        existing = self.compliance_reasons.pluck(:reason)
+        to_delete = existing - reasons
+        to_create = reasons - existing
+        self.compliance_reasons.where(:reason => to_delete).destroy_all if to_delete.any?
+        to_create.each { |reason| self.compliance_reasons.create(:reason => reason) }
+      end
+
+      def virtual_guests
+        ::Host.joins(:subscription_facet).where("#{self.class.table_name}.hypervisor_host_id" => self.host_id)
+      end
+
+      def virtual_guest_uuids
+        virtual_guests.pluck("#{Katello::Host::SubscriptionFacet.table_name}.uuid")
+      end
+
       def update_hypervisor(consumer_params = candlepin_consumer.consumer_attributes)
         if consumer_params.try(:[], 'type').try(:[], 'label') == 'hypervisor'
           self.hypervisor = true
@@ -82,21 +116,11 @@ module Katello
           :autoheal => autoheal,
           :serviceLevel => service_level,
           :releaseVer => release_version,
-          :environment => {:id => self.candlepin_environment_id}
+          :environment => {:id => self.candlepin_environment_id},
+          :installedProducts => self.installed_products.map(&:consumer_attributes),
+          :guestIds => virtual_guest_uuids
         }
         attrs[:facts] = facts if facts
-        attrs[:guestIds] = hypervisor_guest_uuids if hypervisor_guest_uuids
-        if installed_products
-          attrs[:installedProducts] = installed_products.collect do |installed_product|
-            product = {
-              :productName => installed_product[:product_name],
-              :productId => installed_product[:product_id]
-            }
-            product[:arch] = installed_product[:arch] if installed_product[:arch]
-            product[:version] = installed_product[:version] if installed_product[:version]
-            product
-          end
-        end
         HashWithIndifferentAccess.new(attrs)
       end
 
@@ -165,10 +189,20 @@ module Katello
         end
       end
 
-      def self.propose_existing_hostname(facts)
+      def self.propose_custom_fact(facts)
         setting_fact = Setting[:register_hostname_fact]
-        if !setting_fact.blank? && !facts[setting_fact].blank? && ::Host.where(:name => setting_fact.downcase).any?
-          name = facts[setting_fact]
+        only_use_custom_fact = Setting[:register_hostname_fact_strict_match]
+
+        if !setting_fact.blank? && !facts[setting_fact].blank?
+          if only_use_custom_fact || ::Host.where(:name => setting_fact.downcase).any?
+            facts[setting_fact]
+          end
+        end
+      end
+
+      def self.propose_existing_hostname(facts)
+        if propose_custom_fact(facts)
+          name = propose_custom_fact(facts)
         elsif ::Host.where(:name => facts['network.hostname'].downcase).any?
           name = facts['network.hostname']
         elsif !facts['network.fqdn'].blank? && ::Host.where(:name => facts['network.fqdn'].downcase).any?
@@ -192,7 +226,7 @@ module Katello
 
       def self.find_host(facts, organization)
         host_name = propose_existing_hostname(facts)
-        hosts = ::Host.where(:name => host_name)
+        hosts = ::Host.unscoped.where(:name => host_name)
 
         return nil if hosts.empty? #no host exists
         if hosts.where("organization_id = #{organization.id} OR organization_id is NULL").empty? #not in the correct org
@@ -212,8 +246,6 @@ module Katello
       end
 
       def backend_update_needed?
-        return true if self.installed_products || self.hypervisor_guest_uuids
-
         %w(release_version service_level autoheal).each do |method|
           return true if self.send("#{method}_changed?")
         end

data/app/models/katello/host_collection.rb

@@ -1,5 +1,6 @@
 module Katello
   class HostCollection < Katello::Model
+    audited
     include Katello::Authorization::HostCollection
 
     has_many :key_host_collections, :class_name => "Katello::KeyHostCollection", :dependent => :destroy

data/app/models/katello/host_collection_hosts.rb

@@ -1,7 +1,7 @@
 module Katello
   class HostCollectionHosts < Katello::Model
     belongs_to :host, :inverse_of => :host_collection_hosts, :class_name => 'Host::Managed'
-    belongs_to :host_collection, :inverse_of => :host_collection_hosts
+    belongs_to :host_collection, :inverse_of => :host_collection_hosts, :class_name => "Katello::HostCollection"
 
     validate :validate_max_hosts_not_exceeded