katello 3.6.0.1.rc2 → 3.7.0.rc1

data/app/models/katello/repository_docker_manifest.rb

@@ -2,6 +2,6 @@ module Katello
   class RepositoryDockerManifest < Katello::Model
     # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
     belongs_to :repository, :inverse_of => :repository_docker_manifests, :class_name => 'Katello::Repository'
-    belongs_to :docker_manifest, :inverse_of => :repository_docker_manifests
+    belongs_to :docker_manifest, :inverse_of => :repository_docker_manifests, :class_name => 'Katello::DockerManifest'
   end
 end

data/app/models/katello/repository_docker_manifest_list.rb

@@ -2,6 +2,6 @@ module Katello
   class RepositoryDockerManifestList < Katello::Model
     # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
     belongs_to :repository, :inverse_of => :repository_docker_manifest_lists, :class_name => 'Katello::Repository'
-    belongs_to :docker_manifest_list, :inverse_of => :repository_docker_manifest_lists
+    belongs_to :docker_manifest_list, :inverse_of => :repository_docker_manifest_lists, :class_name => 'Katello::DockerManifestList'
   end
 end

data/app/models/katello/repository_ostree_branch.rb

@@ -2,6 +2,6 @@ module Katello
   class RepositoryOstreeBranch < Katello::Model
     # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
     belongs_to :repository, :inverse_of => :repository_ostree_branches, :class_name => 'Katello::Repository'
-    belongs_to :ostree_branch, :inverse_of => :repository_ostree_branches
+    belongs_to :ostree_branch, :inverse_of => :repository_ostree_branches, :class_name => 'Katello::OstreeBranch'
   end
 end

data/app/models/katello/rhsm_fact_importer.rb

@@ -4,24 +4,9 @@ module Katello
       Katello::RhsmFactName
     end
 
-    def normalize(_facts)
-      facts = super
+    def normalize(facts)
       facts = change_separator(facts)
-      add_compose_facts(facts)
-    end
-
-    def add_compose_facts(facts)
-      additional_keys = []
-      facts.each_key do |fact_name|
-        parts = fact_name.split(RhsmFactName::SEPARATOR)
-        additional_keys += parts[0..-2].reduce([]) { |memo, part| memo << [memo.last, part].compact.join(RhsmFactName::SEPARATOR) }
-      end
-
-      # add the facts hierarchy to facts hash
-      additional_keys.uniq.each do |key|
-        facts[key] = nil
-      end
-      facts
+      super(facts)
     end
 
     def change_separator(facts)

data/app/models/katello/subscription.rb

@@ -3,8 +3,6 @@ module Katello
     include Glue::Candlepin::CandlepinObject
     include Glue::Candlepin::Subscription
     include Katello::Authorization::Subscription
-    has_many :subscription_products, :class_name => "Katello::SubscriptionProduct", :dependent => :destroy, :inverse_of => :subscription
-    has_many :products, :through => :subscription_products, :class_name => "Katello::Product"
 
     has_many :pools, :class_name => "Katello::Pool", :inverse_of => :subscription, :dependent => :destroy
 
@@ -14,11 +12,13 @@ module Katello
 
     def self.subscribable
       product_ids = Product.subscribable.pluck(:id) + [nil]
-      joins("LEFT OUTER JOIN #{Katello::SubscriptionProduct.table_name} subprod ON #{self.table_name}.id = subprod.subscription_id")
-        .where("subprod.product_id" => product_ids)
+      joins(:pools).joins("LEFT OUTER JOIN #{Katello::PoolProduct.table_name} pool_prod ON #{Pool.table_name}.id = pool_prod.pool_id")
+        .where("pool_prod.product_id" => product_ids)
         .group("#{self.table_name}.id")
     end
 
+    delegate :user_ids, :to => :organization
+
     def self.using_virt_who
       joins(:pools).where("#{Katello::Pool.table_name}.virt_who" => true)
     end
@@ -26,7 +26,7 @@ module Katello
     def redhat?
       # for custom subscriptions, there is no separate marketing and engineering product
       #   so query our Products table and check there
-      product = Katello::Product.where(:cp_id => self.product_id, :organization => self.organization).first
+      product = Katello::Product.where(:cp_id => self.cp_id, :organization => self.organization).first
       product.nil? || product.redhat?
     end
 

data/app/models/katello/subscription_facet_installed_product.rb

@@ -0,0 +1,6 @@
+module Katello
+  class SubscriptionFacetInstalledProduct < Katello::Model
+    belongs_to :subscription_facet, :inverse_of => :subscription_facet_installed_products, :class_name => 'Katello::Host::SubscriptionFacet'
+    belongs_to :installed_product, :inverse_of => :subscription_facet_installed_products, :class_name => 'Katello::InstalledProduct'
+  end
+end

data/app/models/katello/subscription_facet_pool.rb

@@ -1,5 +1,7 @@
 module Katello
   class SubscriptionFacetPool < Katello::Model
+    # Note: Do not use active record call backs or dependent references on this class
+    # Direct deletes are made in Pool#import_hosts (instead of destroys).
     belongs_to :subscription_facet, :inverse_of => :subscription_facet_pools, :class_name => 'Katello::Host::SubscriptionFacet'
     belongs_to :pool, :inverse_of => :subscription_facet_pools, :class_name => 'Katello::Pool'
   end

data/app/models/katello/sync_plan.rb

@@ -2,6 +2,7 @@ require 'time'
 
 module Katello
   class SyncPlan < Katello::Model
+    audited :associations => [:products]
     include Glue
     include Katello::Authorization::SyncPlan
     include ForemanTasks::Concerns::ActionSubject

data/app/models/katello/upstream_pool.rb

@@ -0,0 +1,112 @@
+module Katello
+  class UpstreamPool < OpenStruct
+    CP_POOL = Resources::Candlepin::UpstreamPool
+
+    class << self
+      def fetch_pools(params)
+        quantities_only = ::Foreman::Cast.to_bool(params.delete(:quantities_only))
+        pool_id_map = upstream_pool_id_map(params.delete(:pool_ids))
+
+        cp_params = request_params(
+          base_params: base_params(params),
+          extra_params: pool_id_params(pool_id_map.keys),
+          included_fields: included_field_params(quantities_only)
+        )
+
+        upstream_response = CP_POOL.get(params: cp_params)
+        pools = response_to_pools(upstream_response, pool_id_map: pool_id_map)
+        total = upstream_response.headers[total_count_header] || pools.count
+
+        respond(pools, total)
+      end
+
+      def respond(pools, total)
+        {
+          pools: pools,
+          total: total,
+          subtotal: pools.count
+        }
+      end
+
+      def base_params(params)
+        attachable = ::Foreman::Cast.to_bool(params.delete(:attachable))
+        params[:consumer] = upstream_consumer_id if attachable
+        params
+      end
+
+      def upstream_consumer_id
+        CP_POOL.upstream_consumer_id
+      end
+
+      def upstream_pool_id_map(local_pool_ids)
+        return {} unless local_pool_ids
+
+        Katello::Candlepin::PoolService.local_to_upstream_ids(local_pool_ids)
+      end
+
+      def response_to_pools(response, pool_id_map: {})
+        pools = JSON.parse(response)
+        pools.map { |pool| self.new(map_attributes(pool, pool_id_map: pool_id_map)) }
+      end
+
+      def kat_to_cp_map
+        {
+          pool_id: 'id',
+          active: 'activeSubscription',
+          quantity: 'quantity',
+          start_date: 'startDate',
+          end_date: 'endDate',
+          contract_number: 'contractNumber',
+          consumed: 'consumed',
+          product_name: 'productName',
+          product_id: 'productId',
+          subscription_id: 'subscriptionId'
+        }
+      end
+
+      def map_attributes(pool, pool_id_map: {})
+        attributes = {}
+        kat_to_cp_map.map do |kat, cp|
+          attributes[kat] = pool[cp] if pool[cp]
+        end
+
+        attributes[:local_pool_ids] = pool_id_map[attributes[:pool_id]]
+
+        attributes
+      end
+
+      def minimal_fields
+        kat_to_cp_map.values_at(:pool_id, :quantity)
+      end
+
+      def all_fields
+        kat_to_cp_map.values
+      end
+
+      def request_params(base_params: {}, extra_params: [], included_fields: [])
+        # use extra_params when you have duplicate keys
+        # i.e. [[:michael, "bolton"], [:michael, "jordan"]]
+        included_fields.map! { |field| [:include, field] }
+        RestClient::ParamsArray.new(base_params.to_a + extra_params + included_fields)
+      end
+
+      def pool_id_params(pool_ids)
+        pool_ids ? pool_ids.map { |pool| [:poolid, pool] } : []
+      end
+
+      def included_field_params(quantities_only)
+        quantities_only ? minimal_fields : all_fields
+      end
+
+      def total_count_header
+        Katello::Resources::Candlepin::TOTAL_COUNT_HEADER
+      end
+    end
+
+    def available
+      return -1 if self.quantity == -1
+      return 0 unless self.quantity && self.consumed
+      self.quantity - self.consumed
+    end
+  end
+end

data/app/models/setting/content.rb

@@ -13,11 +13,11 @@ class Setting::Content < Setting
     self.transaction do
       [
         self.set('katello_default_provision', N_("Default provisioning template for Operating Systems created from synced content"),
-                 'Katello Kickstart Default', N_('Default synced OS provisioning template')),
+                 'Kickstart default', N_('Default synced OS provisioning template')),
         self.set('katello_default_finish', N_("Default finish template for new Operating Systems created from synced content"),
-                 'Katello Kickstart Default Finish', N_('Default synced OS finish template')),
+                 'Kickstart default finish', N_('Default synced OS finish template')),
         self.set('katello_default_user_data', N_("Default user data for new Operating Systems created from synced content"),
-                 'Katello Kickstart Default User Data', N_('Default synced OS user-data')),
+                 'Kickstart default user data', N_('Default synced OS user-data')),
         self.set('katello_default_PXELinux', N_("Default PXELinux template for new Operating Systems created from synced content"),
                  'Kickstart default PXELinux', N_('Default synced OS PXELinux template')),
         self.set('katello_default_PXEGrub', N_("Default PXEGrub template for new Operating Systems created from synced content"),
@@ -31,12 +31,14 @@ class Setting::Content < Setting
         self.set('katello_default_kexec', N_("Default kexec template for new Operating Systems created from synced content"),
                  'Discovery Red Hat kexec', N_('Default synced OS kexec template')),
         self.set('katello_default_atomic_provision', N_("Default provisioning template for new Atomic Operating Systems created from synced content"),
-                 'Katello Atomic Kickstart Default', N_('Default synced OS Atomic template')),
+                 'Atomic Kickstart default', N_('Default synced OS Atomic template')),
         self.set('manifest_refresh_timeout', N_('Timeout when refreshing a manifest (in seconds)'), 60 * 20, N_("Manifest refresh timeout")),
         self.set('content_action_accept_timeout', N_("Time in seconds to wait for a Host to pickup a remote action"),
                  20, N_('Accept action timeout')),
         self.set('content_action_finish_timeout', N_("Time in seconds to wait for a Host to finish a remote action"),
                  3600, N_('Finish action timeout')),
+        self.set('content_disconnected', N_("A server operating in disconnected mode does not communicate with the Red Hat CDN."),
+                 false, N_('Disconnected mode')),
         self.set('errata_status_installable', N_("Calculate errata host status based only on errata in a Host's Content View and Lifecycle Environment"),
                  false, N_('Installable errata from Content View')),
         self.set('restrict_composite_view', N_("If set to true, a composite content view may not be published or "\
@@ -44,8 +46,6 @@ class Setting::Content < Setting
                  false, N_('Restrict Composite Content View promotion')),
         self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."),
                  true, N_('Check services before actions')),
-        self.set('force_post_sync_actions', N_("Force post sync actions such as indexing and email even if no content was available."),
-                 false, N_('Force post-sync actions')),
         self.set('default_download_policy', N_("Default download policy for repositories (either 'immediate', 'on_demand', or 'background')"), "on_demand",
                  N_('Default Repository download policy'), nil, :collection => download_policies),
         self.set('default_proxy_download_policy', N_("Default download policy for Smart Proxy syncs (either 'inherit', immediate', 'on_demand', or 'background')"), "on_demand",
@@ -65,6 +65,8 @@ class Setting::Content < Setting
                  false, N_('Delete Host upon unregister')),
         self.set('register_hostname_fact', N_("When registering a host via subscription-manager, force use the specified fact (in the form of 'fact.fact')"),
                  '', N_('Subscription manager name registration fact'), nil),
+        self.set('register_hostname_fact_strict_match', N_('If true, and register_hostname_fact is set and provided, registration will look for a new host by name only '\
+                  'using that fact, and will skip all hostname matching'), false, N_('Subscription manager name registration fact strict matching'), nil),
         self.set('erratum_install_batch_size', N_("Errata installed via katello-agent will be triggered in batches of this size. Set to 0 to install all errata in one batch."),
                  0, N_('Erratum Install Batch Size')),
         self.set('default_location_subscribed_hosts',
@@ -74,7 +76,9 @@ class Setting::Content < Setting
         self.set('default_location_puppet_content',
                  N_('Default Location where new Puppet content will be put upon Content View publish'),
                  nil, N_('Default Location Puppet content'), nil,
-                 :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] })
+                 :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
+        self.set('expire_soon_days', N_('The number of days remaining in a subscription before you will be reminded about renewing it.'),
+                 120, N_('Expire soon days'))
       ].each { |s| self.create! s.update(:category => "Setting::Content") }
     end
     true

data/app/services/katello/candlepin/consumer.rb

@@ -117,8 +117,13 @@ module Katello
       end
 
       def compliance_reasons
-        Resources::Candlepin::Consumer.compliance(uuid)['reasons'].map do |reason|
-          "#{reason['attributes']['name']}: #{reason['message']}"
+        self.class.friendly_compliance_reasons(Resources::Candlepin::Consumer.compliance(uuid)['reasons'])
+      end
+
+      def self.friendly_compliance_reasons(candlepin_reasons)
+        candlepin_reasons.map do |reason|
+          product_name = reason['productName'] || reason['attributes']['name']
+          "#{product_name}: #{reason['message']}"
         end
       end
 
@@ -132,6 +137,8 @@ module Katello
           'CentOS'
         elsif name =~ /fedora/
           'Fedora'
+        elsif name =~ /sles/ || name =~ /suse.*enterprise.*/
+          'SLES'
         end
       end
     end

data/app/services/katello/candlepin/message_handler.rb

@@ -16,35 +16,33 @@ module Katello
         JSON.parse(@message.content)
       end
 
-      def reference_id
-        self.content['referenceId']
+      def event_data
+        data = content['eventData']
+        data ? JSON.parse(data) : {}
       end
 
-      def entity_id
-        self.content['entityId']
+      def sub_status
+        event_data['status']
       end
 
-      def new_entity
-        self.content['newEntity']
+      def consumer_reasons
+        event_data['reasons']
       end
 
-      def old_entity
-        self.content['oldEntity']
+      def consumer_uuid
+        content['consumerUuid']
       end
 
-      def sub_status
-        if self.new_entity
-          parsed = JSON.parse(self.new_entity)
-          parsed['status']['status']
+      def pool_id
+        if subject == 'pool.created' || subject == 'pool.deleted'
+          content['entityId']
+        elsif subject == 'entitlement.created' ||  subject == 'entitlement.deleted'
+          content['referenceId']
         end
       end
 
-      def consumer_uuid
-        entity = self.new_entity || self.old_entity
-        if entity
-          parsed = JSON.parse(entity)
-          parsed['consumer']['uuid']
-        end
+      def pool
+        Katello::Pool.find_by(:cp_id => pool_id)
       end
 
       def subscription_facet
@@ -54,38 +52,23 @@ module Katello
 
       def create_pool_on_host
         return if self.subscription_facet.nil?
-        pool = self.pool_by_reference_id
         ::Katello::SubscriptionFacetPool.where(subscription_facet_id: self.subscription_facet.id,
                                                pool_id: pool.id).first_or_create
       end
 
       def remove_pool_from_host
-        return if self.subscription_facet.nil?
-        pool = self.pool_by_reference_id
+        return if self.subscription_facet.nil? || pool.nil?
         ::Katello::SubscriptionFacetPool.where(subscription_facet_id: self.subscription_facet.id,
                                                pool_id: pool.id).destroy_all
       end
 
-      def import_pool(pool_id, index_hosts = true)
-        pool = ::Katello::Pool.find_by(:cp_id => pool_id)
+      def import_pool(index_hosts = true)
         if pool
           ::Katello::EventQueue.push_event(::Katello::Events::ImportPool::EVENT_TYPE, pool.id)
         else
           ::Katello::Pool.import_pool(pool_id, index_hosts)
         end
       end
-
-      def pool_by_reference_id
-        ::Katello::Pool.where(:cp_id => self.reference_id).first
-      end
-
-      def import_pool_by_reference_id
-        self.import_pool(self.reference_id, false)
-      end
-
-      def import_pool_by_entity_id
-        self.import_pool(self.entity_id, false)
-      end
     end
   end
 end

data/app/services/katello/candlepin/pool_service.rb

@@ -0,0 +1,17 @@
+module Katello
+  module Candlepin
+    class PoolService
+      def self.local_to_upstream_ids(local_pool_ids)
+        pools = Katello::Pool.find(local_pool_ids)
+        id_map = Hash.new { |hash, key| hash[key] = [] }
+
+        pools.each do |pool|
+          fail 'No upstream pool ID was found for Katello::Pool with ID: %s' % pool.id unless pool.upstream_pool_id
+          id_map[pool.upstream_pool_id] << pool.id
+        end
+
+        id_map
+      end
+    end
+  end
+end

data/app/services/katello/event_queue.rb

@@ -3,18 +3,23 @@ module Katello
     @event_types = {}
 
     def self.clear_events(event_type, object_id, on_or_earlier_than)
-      Katello::Event.where(:in_progress => true, :object_id => object_id, :event_type => event_type).where('created_at <= ?', on_or_earlier_than).destroy_all
+      Katello::Event.where(:in_progress => true, :object_id => object_id, :event_type => event_type).where('created_at <= ?', on_or_earlier_than).delete_all
     end
 
     def self.next_event
-      first = Katello::Event.where(:in_progress => false).order(:created_at => 'asc').limit(1)
-      events = Katello::Event.where(:in_progress => false, :object_id => first.pluck(:object_id),
-                                    :event_type => first.pluck(:event_type)).order(:created_at => 'asc')
-      last = events.last
-      events.update_all(:in_progress => true)
+      first = Katello::Event.where(:in_progress => false).order(:created_at => 'asc').first
+      return if first.nil?
+      last = ::Katello::Event.where(:in_progress => false, :object_id => first.object_id,
+                                    :event_type => first.event_type).order(:created_at => 'desc').first
+      mark_in_progress(first)
       last
     end
 
+    def self.mark_in_progress(event)
+      ::Katello::Event.where(:in_progress => false, :object_id => event.object_id, :event_type => event.event_type).
+                       update_all(:in_progress => true)
+    end
+
     def self.reset_in_progress
       Katello::Event.where(:in_progress => true).update_all(:in_progress => false)
     end